## v0.4.16

- 增加 ISelect.AsType 实现弱类型查询，配合 Select<object>().AsType(实体类型)； - 补充 ISelect.From<T2>； - 补充 ExpressionTree 单元测试； - 优化 ToList(a => new Dto())，会按优先级查询 Join 实体属性；
2025-06-19 12:28:15 +08:00 · 2019-04-16 22:48:11 +08:00
parent 66ec123d8a
commit 0d2191ca85
22 changed files with 1043 additions and 117 deletions
--- a/FreeSql/Extensions/EntityUtilExtensions.cs
+++ b/FreeSql/Extensions/EntityUtilExtensions.cs
@ -21,10 +21,14 @@ namespace FreeSql.Extensions.EntityUtil {
 		/// </summary>
 		/// <typeparam name="TEntity"></typeparam>
 		/// <param name="_table"></param>
-		/// <param name="item"></param>
+		/// <param name="entity"></param>
 		/// <returns></returns>
-		public static string GetEntityKeyString<TEntity>(this IFreeSql orm, TEntity item, string splitString = "*|_,[,_|*") {
-			var func = _dicGetEntityKeyString.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Func<object, string>>()).GetOrAdd(typeof(TEntity), t => {
+		public static void GetEntityKeyString<TEntity>(this IFreeSql orm, TEntity entity, string splitString = "*|_,[,_|*") =>
+			GetEntityKeyString(orm, typeof(TEntity), entity, splitString);
+		public static string GetEntityKeyString(this IFreeSql orm, Type entityType, object entity, string splitString = "*|_,[,_|*") {
+			if (entity == null) return null;
+			if (entityType == null) entityType = entity.GetType();
+			var func = _dicGetEntityKeyString.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Func<object, string>>()).GetOrAdd(entityType, t => {
 				var _table = orm.CodeFirst.GetTableByEntity(t);
 				var pks = _table.Primarys;
 				var returnTarget = Expression.Label(typeof(string));
@ -96,7 +100,7 @@ namespace FreeSql.Extensions.EntityUtil {
 				exps.Add(Expression.Label(returnTarget, Expression.Default(typeof(string))));
 				return Expression.Lambda<Func<object, string>>(Expression.Block(new[] { var1Parm, var2Sb, var3IsNull }, exps), new[] { parm1 }).Compile();
 			});
-			return func(item);
+			return func(entity);
 		}
 		static ConcurrentDictionary<DataType, ConcurrentDictionary<Type, Func<object, object[]>>> _dicGetEntityKeyValues = new ConcurrentDictionary<DataType, ConcurrentDictionary<Type, Func<object, object[]>>>();
 		/// <summary>
@ -104,10 +108,14 @@ namespace FreeSql.Extensions.EntityUtil {
 		/// </summary>
 		/// <typeparam name="TEntity"></typeparam>
 		/// <param name="_table"></param>
-		/// <param name="item"></param>
+		/// <param name="entity"></param>
 		/// <returns></returns>
-		public static object[] GetEntityKeyValues<TEntity>(this IFreeSql orm, TEntity item) {
-			var func = _dicGetEntityKeyValues.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Func<object, object[]>>()).GetOrAdd(typeof(TEntity), t => {
+		public static void GetEntityKeyValues<TEntity>(this IFreeSql orm, TEntity entity) =>
+			GetEntityKeyValues(orm, typeof(TEntity), entity);
+		public static object[] GetEntityKeyValues(this IFreeSql orm, Type entityType, object entity) {
+			if (entity == null) return null;
+			if (entityType == null) entityType = entity.GetType();
+			var func = _dicGetEntityKeyValues.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Func<object, object[]>>()).GetOrAdd(entityType, t => {
 				var _table = orm.CodeFirst.GetTableByEntity(t);
 				var pks = _table.Primarys;
 				var returnTarget = Expression.Label(typeof(object[]));
@ -132,7 +140,7 @@ namespace FreeSql.Extensions.EntityUtil {
 				});
 				return Expression.Lambda<Func<object, object[]>>(Expression.Block(new[] { var1Parm, var2Ret }, exps), new[] { parm1 }).Compile();
 			});
-			return func(item);
+			return func(entity);
 		}
 		static ConcurrentDictionary<DataType, ConcurrentDictionary<Type, Func<object, string>>> _dicGetEntityString = new ConcurrentDictionary<DataType, ConcurrentDictionary<Type, Func<object, string>>>();
 		/// <summary>
@ -140,10 +148,14 @@ namespace FreeSql.Extensions.EntityUtil {
 		/// </summary>
 		/// <typeparam name="TEntity"></typeparam>
 		/// <param name="_table"></param>
-		/// <param name="item"></param>
+		/// <param name="entity"></param>
 		/// <returns></returns>
-		public static string GetEntityString<TEntity>(this IFreeSql orm, TEntity item) {
-			var func = _dicGetEntityString.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Func<object, string>>()).GetOrAdd(typeof(TEntity), t => {
+		public static void GetEntityString<TEntity>(this IFreeSql orm, TEntity entity) =>
+			GetEntityString(orm, typeof(TEntity), entity);
+		public static string GetEntityString(this IFreeSql orm, Type entityType, object entity) {
+			if (entity == null) return null;
+			if (entityType == null) entityType = entity.GetType();
+			var func = _dicGetEntityString.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Func<object, string>>()).GetOrAdd(entityType, t => {
 				var _table = orm.CodeFirst.GetTableByEntity(t);
 				var cols = _table.Columns;
 				var returnTarget = Expression.Label(typeof(string));
@ -176,15 +188,18 @@ namespace FreeSql.Extensions.EntityUtil {
 				});
 				return Expression.Lambda<Func<object, string>>(Expression.Block(new[] { var1Parm, var2Sb }, exps), new[] { parm1 }).Compile();
 			});
-			return func(item);
+			return func(entity);
 		}

 		/// <summary>
 		/// 使用新实体的值，复盖旧实体的值
 		/// </summary>
 		static ConcurrentDictionary<DataType, ConcurrentDictionary<Type, Action<object, object>>> _dicMapEntityValue = new ConcurrentDictionary<DataType, ConcurrentDictionary<Type, Action<object, object>>>();
-		public static void MapEntityValue<TEntity>(this IFreeSql orm, TEntity from, TEntity to) {
-			var func = _dicMapEntityValue.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Action<object, object>>()).GetOrAdd(typeof(TEntity), t => {
+		public static void MapEntityValue<TEntity>(this IFreeSql orm, TEntity entityFrom, TEntity entityTo) =>
+			MapEntityValue(orm, typeof(TEntity), entityFrom, entityTo);
+		public static void MapEntityValue(this IFreeSql orm, Type entityType, object entityFrom, object entityTo) {
+			if (entityType == null) entityType = entityFrom?.GetType() ?? entityTo?.GetType();
+			var func = _dicMapEntityValue.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Action<object, object>>()).GetOrAdd(entityType, t => {
 				var _table = orm.CodeFirst.GetTableByEntity(t);
 				var parm1 = Expression.Parameter(typeof(object));
 				var parm2 = Expression.Parameter(typeof(object));
@ -213,15 +228,18 @@ namespace FreeSql.Extensions.EntityUtil {
 				}
 				return Expression.Lambda<Action<object, object>>(Expression.Block(new[] { var1Parm, var2Parm }, exps), new[] { parm1, parm2 }).Compile();
 			});
-			func(from, to);
+			func(entityFrom, entityTo);
 		}

 		static ConcurrentDictionary<DataType, ConcurrentDictionary<Type, Action<object, object>>> _dicMapEntityKeyValue = new ConcurrentDictionary<DataType, ConcurrentDictionary<Type, Action<object, object>>>();
 		/// <summary>
 		/// 使用新实体的主键值，复盖旧实体的主键值
 		/// </summary>
-		public static void MapEntityKeyValue<TEntity>(this IFreeSql orm, TEntity from, TEntity to) {
-			var func = _dicMapEntityKeyValue.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Action<object, object>>()).GetOrAdd(typeof(TEntity), t => {
+		public static void MapEntityKeyValue<TEntity>(this IFreeSql orm, TEntity entityFrom, TEntity entityTo) =>
+			MapEntityKeyValue(orm, typeof(TEntity), entityFrom, entityTo);
+		public static void MapEntityKeyValue(this IFreeSql orm, Type entityType, object entityFrom, object entityTo) {
+			if (entityType == null) entityType = entityFrom?.GetType() ?? entityTo?.GetType();
+			var func = _dicMapEntityKeyValue.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Action<object, object>>()).GetOrAdd(entityType, t => {
 				var _table = orm.CodeFirst.GetTableByEntity(t);
 				var pks = _table.Primarys;
 				var parm1 = Expression.Parameter(typeof(object));
@ -242,7 +260,7 @@ namespace FreeSql.Extensions.EntityUtil {
 				}
 				return Expression.Lambda<Action<object, object>>(Expression.Block(new[] { var1Parm, var2Parm }, exps), new[] { parm1, parm2 }).Compile();
 			});
-			func(from, to);
+			func(entityFrom, entityTo);
 		}

 		static ConcurrentDictionary<DataType, ConcurrentDictionary<Type, Action<object, long>>> _dicSetEntityIdentityValueWithPrimary = new ConcurrentDictionary<DataType, ConcurrentDictionary<Type, Action<object, long>>>();
@ -251,10 +269,14 @@ namespace FreeSql.Extensions.EntityUtil {
 		/// </summary>
 		/// <typeparam name="TEntity"></typeparam>
 		/// <param name="orm"></param>
-		/// <param name="item"></param>
+		/// <param name="entity"></param>
 		/// <param name="idtval"></param>
-		public static void SetEntityIdentityValueWithPrimary<TEntity>(this IFreeSql orm, TEntity item, long idtval) {
-			var func = _dicSetEntityIdentityValueWithPrimary.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Action<object, long>>()).GetOrAdd(typeof(TEntity), t => {
+		public static void SetEntityIdentityValueWithPrimary<TEntity>(this IFreeSql orm, TEntity entity, long idtval) =>
+			SetEntityIdentityValueWithPrimary(orm, typeof(TEntity), entity, idtval);
+		public static void SetEntityIdentityValueWithPrimary(this IFreeSql orm, Type entityType, object entity, long idtval) {
+			if (entity == null) return;
+			if (entityType == null) entityType = entity.GetType();
+			var func = _dicSetEntityIdentityValueWithPrimary.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Action<object, long>>()).GetOrAdd(entityType, t => {
 				var _table = orm.CodeFirst.GetTableByEntity(t);
 				var identitys = _table.Primarys.Where(a => a.Attribute.IsIdentity);
 				var parm1 = Expression.Parameter(typeof(object));
@ -274,7 +296,7 @@ namespace FreeSql.Extensions.EntityUtil {
 				}
 				return Expression.Lambda<Action<object, long>>(Expression.Block(new[] { var1Parm }, exps), new[] { parm1, parm2 }).Compile();
 			});
-			func(item, idtval);
+			func(entity, idtval);
 		}
 		static ConcurrentDictionary<DataType, ConcurrentDictionary<Type, Func<object, long>>> _dicGetEntityIdentityValueWithPrimary = new ConcurrentDictionary<DataType, ConcurrentDictionary<Type, Func<object, long>>>();
 		/// <summary>
@ -282,9 +304,13 @@ namespace FreeSql.Extensions.EntityUtil {
 		/// </summary>
 		/// <typeparam name="TEntity"></typeparam>
 		/// <param name="orm"></param>
-		/// <param name="item"></param>
-		public static long GetEntityIdentityValueWithPrimary<TEntity>(this IFreeSql orm, TEntity item) {
-			var func = _dicGetEntityIdentityValueWithPrimary.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Func<object, long>>()).GetOrAdd(typeof(TEntity), t => {
+		/// <param name="entity"></param>
+		public static void GetEntityIdentityValueWithPrimary<TEntity>(this IFreeSql orm, TEntity entity) =>
+			GetEntityIdentityValueWithPrimary(orm, typeof(TEntity), entity);
+		public static long GetEntityIdentityValueWithPrimary(this IFreeSql orm, Type entityType, object entity) {
+			if (entity == null) return 0;
+			if (entityType == null) entityType = entity.GetType();
+			var func = _dicGetEntityIdentityValueWithPrimary.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Func<object, long>>()).GetOrAdd(entityType, t => {
 				var _table = orm.CodeFirst.GetTableByEntity(t);
 				var identitys = _table.Primarys.Where(a => a.Attribute.IsIdentity);
 				var returnTarget = Expression.Label(typeof(long));
@ -317,7 +343,7 @@ namespace FreeSql.Extensions.EntityUtil {
 				exps.Add(Expression.Label(returnTarget, Expression.Default(typeof(long))));
 				return Expression.Lambda<Func<object, long>>(Expression.Block(new[] { var1Parm }, exps), new[] { parm1 }).Compile();
 			});
-			return func(item);
+			return func(entity);
 		}

 		static ConcurrentDictionary<DataType, ConcurrentDictionary<Type, Action<object>>> _dicClearEntityPrimaryValueWithIdentityAndGuid = new ConcurrentDictionary<DataType, ConcurrentDictionary<Type, Action<object>>>();
@ -326,9 +352,13 @@ namespace FreeSql.Extensions.EntityUtil {
 		/// </summary>
 		/// <typeparam name="TEntity"></typeparam>
 		/// <param name="orm"></param>
-		/// <param name="item"></param>
-		public static void ClearEntityPrimaryValueWithIdentityAndGuid<TEntity>(this IFreeSql orm, TEntity item) {
-			var func = _dicClearEntityPrimaryValueWithIdentityAndGuid.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Action<object>>()).GetOrAdd(typeof(TEntity), t => {
+		/// <param name="entity"></param>
+		public static void ClearEntityPrimaryValueWithIdentityAndGuid<TEntity>(this IFreeSql orm, TEntity entity) =>
+			ClearEntityPrimaryValueWithIdentityAndGuid(orm, typeof(TEntity), entity);
+		public static void ClearEntityPrimaryValueWithIdentityAndGuid(this IFreeSql orm, Type entityType, object entity) {
+			if (entity == null) return;
+			if (entityType == null) entityType = entity.GetType();
+			var func = _dicClearEntityPrimaryValueWithIdentityAndGuid.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Action<object>>()).GetOrAdd(entityType, t => {
 				var _table = orm.CodeFirst.GetTableByEntity(t);
 				var identitys = _table.Primarys.Where(a => a.Attribute.IsIdentity);
 				var parm1 = Expression.Parameter(typeof(object));
@ -349,7 +379,7 @@ namespace FreeSql.Extensions.EntityUtil {
 				}
 				return Expression.Lambda<Action<object>>(Expression.Block(new[] { var1Parm }, exps), new[] { parm1 }).Compile();
 			});
-			func(item);
+			func(entity);
 		}

 		static ConcurrentDictionary<DataType, ConcurrentDictionary<Type, Action<object>>> _dicClearEntityPrimaryValueWithIdentity = new ConcurrentDictionary<DataType, ConcurrentDictionary<Type, Action<object>>>();
@ -358,9 +388,13 @@ namespace FreeSql.Extensions.EntityUtil {
 		/// </summary>
 		/// <typeparam name="TEntity"></typeparam>
 		/// <param name="orm"></param>
-		/// <param name="item"></param>
-		public static void ClearEntityPrimaryValueWithIdentity<TEntity>(this IFreeSql orm, TEntity item) {
-			var func = _dicClearEntityPrimaryValueWithIdentity.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Action<object>>()).GetOrAdd(typeof(TEntity), t => {
+		/// <param name="entity"></param>
+		public static void ClearEntityPrimaryValueWithIdentity<TEntity>(this IFreeSql orm, TEntity entity) =>
+			ClearEntityPrimaryValueWithIdentity(orm, typeof(TEntity), entity);
+		public static void ClearEntityPrimaryValueWithIdentity(this IFreeSql orm, Type entityType, object entity) {
+			if (entity == null) return;
+			if (entityType == null) entityType = entity.GetType();
+			var func = _dicClearEntityPrimaryValueWithIdentity.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Action<object>>()).GetOrAdd(entityType, t => {
 				var _table = orm.CodeFirst.GetTableByEntity(t);
 				var identitys = _table.Primarys.Where(a => a.Attribute.IsIdentity);
 				var parm1 = Expression.Parameter(typeof(object));
@ -380,7 +414,7 @@ namespace FreeSql.Extensions.EntityUtil {
 				}
 				return Expression.Lambda<Action<object>>(Expression.Block(new[] { var1Parm }, exps), new[] { parm1 }).Compile();
 			});
-			func(item);
+			func(entity);
 		}

 		static ConcurrentDictionary<DataType, ConcurrentDictionary<Type, Func<object, object, bool, string[]>>> _dicCompareEntityValueReturnColumns = new ConcurrentDictionary<DataType, ConcurrentDictionary<Type, Func<object, object, bool, string[]>>>();
@ -389,11 +423,14 @@ namespace FreeSql.Extensions.EntityUtil {
 		/// </summary>
 		/// <typeparam name="TEntity"></typeparam>
 		/// <param name="orm"></param>
-		/// <param name="up"></param>
-		/// <param name="oldval"></param>
+		/// <param name="entity1"></param>
+		/// <param name="entity2"></param>
 		/// <returns></returns>
-		public static string[] CompareEntityValueReturnColumns<TEntity>(this IFreeSql orm, TEntity up, TEntity oldval, bool isEqual) {
-			var func = _dicCompareEntityValueReturnColumns.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Func<object, object, bool, string[]>>()).GetOrAdd(typeof(TEntity), t => {
+		public static void CompareEntityValueReturnColumns<TEntity>(this IFreeSql orm, TEntity entity1, TEntity entity2, bool isEqual) =>
+			CompareEntityValueReturnColumns(orm, typeof(TEntity), entity1, entity2, isEqual);
+		public static string[] CompareEntityValueReturnColumns(this IFreeSql orm, Type entityType, object entity1, object entity2, bool isEqual) {
+			if (entityType == null) entityType = entity1?.GetType() ?? entity2?.GetType();
+			var func = _dicCompareEntityValueReturnColumns.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Func<object, object, bool, string[]>>()).GetOrAdd(entityType, t => {
 				var _table = orm.CodeFirst.GetTableByEntity(t);
 				var returnTarget = Expression.Label(typeof(string[]));
 				var parm1 = Expression.Parameter(typeof(object));
@ -432,7 +469,7 @@ namespace FreeSql.Extensions.EntityUtil {
 				exps.Add(Expression.Label(returnTarget, Expression.Constant(new string[0])));
 				return Expression.Lambda<Func<object, object, bool, string[]>>(Expression.Block(new[] { var1Ret, var1Parm, var2Parm }, exps), new[] { parm1, parm2, parm3 }).Compile();
 			});
-			return func(up, oldval, isEqual);
+			return func(entity1, entity2, isEqual);
 		}

 		static ConcurrentDictionary<DataType, ConcurrentDictionary<Type, Action<object, string, int>>> _dicSetEntityIncrByWithPropertyName = new ConcurrentDictionary<DataType, ConcurrentDictionary<Type, Action<object, string, int>>>();
@ -441,10 +478,15 @@ namespace FreeSql.Extensions.EntityUtil {
 		/// </summary>
 		/// <typeparam name="TEntity"></typeparam>
 		/// <param name="orm"></param>
-		/// <param name="item"></param>
-		/// <param name="idtval"></param>
-		public static void SetEntityIncrByWithPropertyName<TEntity>(this IFreeSql orm, TEntity item, string propertyName, int incrBy) {
-			var func = _dicSetEntityIncrByWithPropertyName.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Action<object, string, int>>()).GetOrAdd(typeof(TEntity), t => {
+		/// <param name="entity"></param>
+		/// <param name="propertyName"></param>
+		/// <param name="value"></param>
+		public static void SetEntityIncrByWithPropertyName<TEntity>(this IFreeSql orm, TEntity entity, string propertyName, int incrBy) =>
+			SetEntityIncrByWithPropertyName(orm, typeof(TEntity), entity, propertyName, incrBy);
+		public static void SetEntityIncrByWithPropertyName(this IFreeSql orm, Type entityType, object entity, string propertyName, int incrBy) {
+			if (entity == null) return;
+			if (entityType == null) entityType = entity.GetType();
+			var func = _dicSetEntityIncrByWithPropertyName.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Action<object, string, int>>()).GetOrAdd(entityType, t => {
 				var _table = orm.CodeFirst.GetTableByEntity(t);
 				var parm1 = Expression.Parameter(typeof(object));
 				var parm2 = Expression.Parameter(typeof(string));
@ -470,7 +512,53 @@ namespace FreeSql.Extensions.EntityUtil {
 				}
 				return Expression.Lambda<Action<object, string, int>>(Expression.Block(new[] { var1Parm }, exps), new[] { parm1, parm2, parm3 }).Compile();
 			});
-			func(item, propertyName, incrBy);
+			func(entity, propertyName, incrBy);
+		}
+
+		static ConcurrentDictionary<DataType, ConcurrentDictionary<Type, ConcurrentDictionary<string, Action<object, string, object>>>> _dicSetEntityValueWithPropertyName = new ConcurrentDictionary<DataType, ConcurrentDictionary<Type, ConcurrentDictionary<string, Action<object, string, object>>>>();
+		/// <summary>
+		/// 设置实体中某属性的值
+		/// </summary>
+		/// <typeparam name="TEntity"></typeparam>
+		/// <param name="orm"></param>
+		/// <param name="entity"></param>
+		/// <param name="propertyName"></param>
+		/// <param name="value"></param>
+		public static void SetEntityValueWithPropertyName<TEntity>(this IFreeSql orm, TEntity entity, string propertyName, object value) =>
+			SetEntityValueWithPropertyName(orm, typeof(TEntity), entity, propertyName, value);
+		public static void SetEntityValueWithPropertyName(this IFreeSql orm, Type entityType, object entity, string propertyName, object value) {
+			if (entity == null) return;
+			if (entityType == null) entityType = entity.GetType();
+			var func = _dicSetEntityValueWithPropertyName.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, ConcurrentDictionary<string, Action<object, string, object>>>())
+				.GetOrAdd(entityType, et => new ConcurrentDictionary<string, Action<object, string, object>>())
+				.GetOrAdd(propertyName, pn => {
+					var t = entityType;
+					var _table = orm.CodeFirst.GetTableByEntity(t);
+					var parm1 = Expression.Parameter(typeof(object));
+					var parm2 = Expression.Parameter(typeof(string));
+					var parm3 = Expression.Parameter(typeof(object));
+					var var1Parm = Expression.Variable(t);
+					var exps = new List<Expression>(new Expression[] {
+						Expression.Assign(var1Parm, Expression.TypeAs(parm1, t))
+					});
+					if (_table.Properties.ContainsKey(pn)) {
+						var prop = _table.Properties[pn];
+						exps.Add(
+							Expression.Assign(
+								Expression.MakeMemberAccess(var1Parm, prop),
+								Expression.Add(
+									Expression.MakeMemberAccess(var1Parm, prop),
+									Expression.Convert(
+										FreeSql.Internal.Utils.GetDataReaderValueBlockExpression(prop.PropertyType, parm3),
+										prop.PropertyType
+									)
+								)
+							)
+						);
+					}
+					return Expression.Lambda<Action<object, string, object>>(Expression.Block(new[] { var1Parm }, exps), new[] { parm1, parm2, parm3 }).Compile();
+				});
+			func(entity, propertyName, value);
 		}

 		static ConcurrentDictionary<Type, MethodInfo[]> _dicAppendEntityUpdateSetWithColumnMethods = new ConcurrentDictionary<Type, MethodInfo[]>();
--- a/FreeSql/FreeSql.csproj
+++ b/FreeSql/FreeSql.csproj
@ -2,7 +2,7 @@

 	<PropertyGroup>
 		<TargetFramework>netstandard2.0</TargetFramework>
-		<Version>0.4.15</Version>
+		<Version>0.4.16</Version>
 		<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
 		<Authors>YeXiangQin</Authors>
 		<Description>FreeSql is the most convenient ORM in dotnet. It supports Mysql, Postgresql, SqlServer, Oracle and Sqlite.</Description>
--- a/FreeSql/Interface/Curd/ISelect/ISelect0.cs
+++ b/FreeSql/Interface/Curd/ISelect/ISelect0.cs
@ -71,6 +71,12 @@ namespace FreeSql {
 		/// <returns></returns>
 		TSelect AsTable(Func<Type, string, string> tableRule);
 		/// <summary>
+		/// 动态Type，在使用 Select&lt;object&gt; 后使用本方法，指定实体类型
+		/// </summary>
+		/// <param name="entityType"></param>
+		/// <returns></returns>
+		TSelect AsType(Type entityType);
+		/// <summary>
 		/// 返回即将执行的SQL语句
 		/// </summary>
 		/// <param name="field">指定字段</param>
--- a/FreeSql/Interface/Curd/ISelect/ISelect1.cs
+++ b/FreeSql/Interface/Curd/ISelect/ISelect1.cs
@ -106,6 +106,13 @@ namespace FreeSql {
 		/// <returns></returns>
 		ISelect<T1> As(string alias = "a");

+		/// <summary>
+		/// 多表查询
+		/// </summary>
+		/// <typeparam name="T2"></typeparam>
+		/// <param name="exp"></param>
+		/// <returns></returns>
+		ISelect<T1, T2> From<T2>(Expression<Func<ISelectFromExpression<T1>, T2, ISelectFromExpression<T1>>> exp) where T2 : class;
 		/// <summary>
 		/// 多表查询
 		/// </summary>
--- a/FreeSql/Interface/Curd/ISelect/ISelect2.cs
+++ b/FreeSql/Interface/Curd/ISelect/ISelect2.cs
@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+
+namespace FreeSql {
+	public interface ISelect<T1, T2> : ISelect0<ISelect<T1, T2>, T1> where T1 : class where T2 : class {
+
+		bool Any(Expression<Func<T1, T2, bool>> exp);
+		Task<bool> AnyAsync(Expression<Func<T1, T2, bool>> exp);
+
+		DataTable ToDataTable<TReturn>(Expression<Func<T1, T2, TReturn>> select);
+		Task<DataTable> ToDataTableAsync<TReturn>(Expression<Func<T1, T2, TReturn>> select);
+
+		List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, TReturn>> select);
+		Task<List<TReturn>> ToListAsync<TReturn>(Expression<Func<T1, T2, TReturn>> select);
+		string ToSql<TReturn>(Expression<Func<T1, T2, TReturn>> select);
+
+		TReturn ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, TReturn>> select);
+		Task<TReturn> ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, TReturn>> select);
+
+		TMember Sum<TMember>(Expression<Func<T1, T2, TMember>> column);
+		Task<TMember> SumAsync<TMember>(Expression<Func<T1, T2, TMember>> column);
+		TMember Min<TMember>(Expression<Func<T1, T2, TMember>> column);
+		Task<TMember> MinAsync<TMember>(Expression<Func<T1, T2, TMember>> column);
+		TMember Max<TMember>(Expression<Func<T1, T2, TMember>> column);
+		Task<TMember> MaxAsync<TMember>(Expression<Func<T1, T2, TMember>> column);
+		TMember Avg<TMember>(Expression<Func<T1, T2, TMember>> column);
+		Task<TMember> AvgAsync<TMember>(Expression<Func<T1, T2, TMember>> column);
+
+		ISelect<T1, T2> Where(Expression<Func<T1, T2, bool>> exp);
+		ISelect<T1, T2> WhereIf(bool condition, Expression<Func<T1, T2, bool>> exp);
+
+		ISelectGrouping<TKey> GroupBy<TKey>(Expression<Func<T1, T2, TKey>> exp);
+
+		ISelect<T1, T2> OrderBy<TMember>(Expression<Func<T1, T2, TMember>> column);
+		ISelect<T1, T2> OrderByDescending<TMember>(Expression<Func<T1, T2, TMember>> column);
+	}
+}
--- a/FreeSql/Internal/CommonExpression.cs
+++ b/FreeSql/Internal/CommonExpression.cs
@ -101,19 +101,27 @@ namespace FreeSql.Internal {
 					} else {
 						//dto 映射
 						var dtoProps = _dicReadAnonymousFieldDtoPropertys.GetOrAdd(initExp.NewExpression.Type, dtoType => dtoType.GetProperties());
-						var dtoTb0 = _tables.First();
 						foreach (var dtoProp in dtoProps) {
-							if (dtoTb0.Table.Columns.TryGetValue(dtoProp.Name, out var trydtocol)) {
-								var child = new ReadAnonymousTypeInfo {
-									Property = dtoProp,
-									CsName = dtoProp.Name,
-									CsType = dtoProp.PropertyType
-								};
-								parent.Childs.Add(child);
-								ReadAnonymousField(_tables, field, child, ref index, Expression.Property(dtoTb0.Parameter, dtoTb0.Table.Properties[trydtocol.CsName]), getSelectGroupingMapString);
+							foreach (var dtTb in _tables) {
+								if (dtTb.Table.Columns.TryGetValue(dtoProp.Name, out var trydtocol)) {
+									var child = new ReadAnonymousTypeInfo {
+										Property = dtoProp,
+										CsName = dtoProp.Name,
+										CsType = dtoProp.PropertyType
+									};
+									parent.Childs.Add(child);
+									if (dtTb.Parameter != null)
+										ReadAnonymousField(_tables, field, child, ref index, Expression.Property(dtTb.Parameter, dtTb.Table.Properties[trydtocol.CsName]), getSelectGroupingMapString);
+									else {
+										child.DbField = $"{dtTb.Alias}.{_common.QuoteSqlName(trydtocol.Attribute.Name)}";
+										field.Append(", ").Append(child.DbField);
+										if (index >= 0) field.Append(" as").Append(++index);
+									}
+									break;
+								}
 							}
 						}
-						if (parent.Childs.Any() == false) throw new Exception($"映射异常：{initExp.NewExpression.Type.Name} 没有一个属性名和 {dtoTb0.Table.Type.Name} 相同");
+						if (parent.Childs.Any() == false) throw new Exception($"映射异常：{initExp.NewExpression.Type.Name} 没有一个属性名相同");
 					}
 					return true;
 				case ExpressionType.New:
@ -134,19 +142,27 @@ namespace FreeSql.Internal {
 						//dto 映射
 						parent.ConsturctorType = ReadAnonymousTypeInfoConsturctorType.Properties;
 						var dtoProps = _dicReadAnonymousFieldDtoPropertys.GetOrAdd(newExp.Type, dtoType => dtoType.GetProperties());
-						var dtoTb0 = _tables.First();
 						foreach (var dtoProp in dtoProps) {
-							if (dtoTb0.Table.Columns.TryGetValue(dtoProp.Name, out var trydtocol)) {
-								var child = new ReadAnonymousTypeInfo {
-									Property = dtoProp,
-									CsName = dtoProp.Name,
-									CsType = dtoProp.PropertyType
-								};
-								parent.Childs.Add(child);
-								ReadAnonymousField(_tables, field, child, ref index, Expression.Property(dtoTb0.Parameter, dtoTb0.Table.Properties[trydtocol.CsName]), getSelectGroupingMapString);
+							foreach(var dtTb in _tables) {
+								if (dtTb.Table.ColumnsByCs.TryGetValue(dtoProp.Name, out var trydtocol)) {
+									var child = new ReadAnonymousTypeInfo {
+										Property = dtoProp,
+										CsName = dtoProp.Name,
+										CsType = dtoProp.PropertyType
+									};
+									parent.Childs.Add(child);
+									if (dtTb.Parameter != null)
+										ReadAnonymousField(_tables, field, child, ref index, Expression.Property(dtTb.Parameter, dtTb.Table.Properties[trydtocol.CsName]), getSelectGroupingMapString);
+									else {
+										child.DbField = $"{dtTb.Alias}.{_common.QuoteSqlName(trydtocol.Attribute.Name)}";
+										field.Append(", ").Append(child.DbField);
+										if (index >= 0) field.Append(" as").Append(++index);
+									}
+									break;
+								}
 							}
 						}
-						if (parent.Childs.Any() == false) throw new Exception($"映射异常：{newExp.Type.Name} 没有一个属性名和 {dtoTb0.Table.Type.Name} 相同");
+						if (parent.Childs.Any() == false) throw new Exception($"映射异常：{newExp.Type.Name} 没有一个属性名相同");
 					}
 					return true;
 			}
--- a/FreeSql/Internal/CommonProvider/SelectProvider/Select0Provider.cs
+++ b/FreeSql/Internal/CommonProvider/SelectProvider/Select0Provider.cs
@ -74,7 +74,7 @@ namespace FreeSql.Internal.CommonProvider {
 			_commonExpression = commonExpression;
 			_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T1)), Alias = "a", On = null, Type = SelectTableInfoType.From });
 			this.Where(_commonUtils.WhereObject(_tables.First().Table, "a.", dywhere));
-			if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure<T1>();
+			if (_orm.CodeFirst.IsAutoSyncStructure && typeof(T1) != typeof(object)) _orm.CodeFirst.SyncStructure<T1>();
 		}

 		public TSelect TrackToList(Action<object> track) {
@ -519,6 +519,15 @@ namespace FreeSql.Internal.CommonProvider {
 			if (tableRule != null) _tableRules.Add(tableRule);
 			return this as TSelect;
 		}
+		public TSelect AsType(Type entityType) {
+			if (entityType == typeof(object)) throw new Exception("ISelect.AsType 参数不支持指定为 object");
+			if (entityType == _tables[0].Table.Type) return this as TSelect;
+			var newtb = _commonUtils.GetTableByEntity(entityType);
+			if (newtb == null) throw new Exception("ISelect.AsType 参数错误，请传入正确的实体类型");
+			_tables[0].Table = newtb;
+			if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure(entityType);
+			return this as TSelect;
+		}
 		public abstract string ToSql(string field = null);

 		public TSelect Where(string sql, object parms = null) => this.WhereIf(true, sql, parms);
--- a/FreeSql/Internal/CommonProvider/SelectProvider/Select1Provider.cs
+++ b/FreeSql/Internal/CommonProvider/SelectProvider/Select1Provider.cs
@ -70,6 +70,7 @@ namespace FreeSql.Internal.CommonProvider {
 			return this.InternalAvgAsync<TMember>(column?.Body);
 		}

+		public abstract ISelect<T1, T2> From<T2>(Expression<Func<ISelectFromExpression<T1>, T2, ISelectFromExpression<T1>>> exp) where T2 : class;// { this.InternalFrom(exp?.Body); var ret = new Select3Provider<T1, T2, T3>(_orm, _commonUtils, _commonExpression, null); Select0Provider<ISelect<T1>, T1>.CopyData(this, ret, exp?.Parameters); return ret; }
 		public abstract ISelect<T1, T2, T3> From<T2, T3>(Expression<Func<ISelectFromExpression<T1>, T2, T3, ISelectFromExpression<T1>>> exp) where T2 : class where T3 : class;// { this.InternalFrom(exp?.Body); var ret = new Select3Provider<T1, T2, T3>(_orm, _commonUtils, _commonExpression, null); Select0Provider<ISelect<T1>, T1>.CopyData(this, ret, exp?.Parameters); return ret; }

 		public abstract ISelect<T1, T2, T3, T4> From<T2, T3, T4>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, ISelectFromExpression<T1>>> exp) where T2 : class where T3 : class where T4 : class;// { this.InternalFrom(exp?.Body); var ret = new Select4Provider<T1, T2, T3, T4>(_orm, _commonUtils, _commonExpression, null); Select0Provider<ISelect<T1>, T1>.CopyData(this, ret, exp?.Parameters); return ret; }
--- a/FreeSql/Internal/CommonProvider/SelectProvider/Select2Provider.cs
+++ b/FreeSql/Internal/CommonProvider/SelectProvider/Select2Provider.cs
@ -0,0 +1,152 @@
+using FreeSql.Internal.Model;
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+
+namespace FreeSql.Internal.CommonProvider {
+
+	abstract class Select2Provider<T1, T2> : Select0Provider<ISelect<T1, T2>, T1>, ISelect<T1, T2>
+			where T1 : class
+			where T2 : class {
+
+		public Select2Provider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) {
+			if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure(typeof(T2));
+			_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T2)), Alias = $"SP10b", On = null, Type = SelectTableInfoType.From });
+		}
+
+		TMember ISelect<T1, T2>.Avg<TMember>(Expression<Func<T1, T2, TMember>> column) {
+			if (column == null) return default(TMember);
+			for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
+			return this.InternalAvg<TMember>(column?.Body);
+		}
+
+		Task<TMember> ISelect<T1, T2>.AvgAsync<TMember>(Expression<Func<T1, T2, TMember>> column) {
+			if (column == null) return Task.FromResult(default(TMember));
+			for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
+			return this.InternalAvgAsync<TMember>(column?.Body);
+		}
+
+		ISelectGrouping<TKey> ISelect<T1, T2>.GroupBy<TKey>(Expression<Func<T1, T2, TKey>> exp) {
+			if (exp == null) return this.InternalGroupBy<TKey>(exp?.Body);
+			for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
+			return this.InternalGroupBy<TKey>(exp?.Body);
+		}
+
+		TMember ISelect<T1, T2>.Max<TMember>(Expression<Func<T1, T2, TMember>> column) {
+			if (column == null) return default(TMember);
+			for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
+			return this.InternalMax<TMember>(column?.Body);
+		}
+
+		Task<TMember> ISelect<T1, T2>.MaxAsync<TMember>(Expression<Func<T1, T2, TMember>> column) {
+			if (column == null) return Task.FromResult(default(TMember));
+			for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
+			return this.InternalMaxAsync<TMember>(column?.Body);
+		}
+
+		TMember ISelect<T1, T2>.Min<TMember>(Expression<Func<T1, T2, TMember>> column) {
+			if (column == null) return default(TMember);
+			for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
+			return this.InternalMin<TMember>(column?.Body);
+		}
+
+		Task<TMember> ISelect<T1, T2>.MinAsync<TMember>(Expression<Func<T1, T2, TMember>> column) {
+			if (column == null) return Task.FromResult(default(TMember));
+			for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
+			return this.InternalMinAsync<TMember>(column?.Body);
+		}
+
+		ISelect<T1, T2> ISelect<T1, T2>.OrderBy<TMember>(Expression<Func<T1, T2, TMember>> column) {
+			if (column == null) this.InternalOrderBy(column?.Body);
+			for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
+			return this.InternalOrderBy(column?.Body);
+		}
+
+		ISelect<T1, T2> ISelect<T1, T2>.OrderByDescending<TMember>(Expression<Func<T1, T2, TMember>> column) {
+			if (column == null) this.InternalOrderBy(column?.Body);
+			for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
+			return this.InternalOrderByDescending(column?.Body);
+		}
+
+		TMember ISelect<T1, T2>.Sum<TMember>(Expression<Func<T1, T2, TMember>> column) {
+			if (column == null) this.InternalOrderBy(column?.Body);
+			for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
+			return this.InternalSum<TMember>(column?.Body);
+		}
+
+		Task<TMember> ISelect<T1, T2>.SumAsync<TMember>(Expression<Func<T1, T2, TMember>> column) {
+			if (column == null) this.InternalOrderBy(column?.Body);
+			for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
+			return this.InternalSumAsync<TMember>(column?.Body);
+		}
+
+		TReturn ISelect<T1, T2>.ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, TReturn>> select) {
+			if (select == null) return default(TReturn);
+			for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
+			return this.InternalToAggregate<TReturn>(select?.Body);
+		}
+
+		Task<TReturn> ISelect<T1, T2>.ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, TReturn>> select) {
+			if (select == null) return Task.FromResult(default(TReturn));
+			for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
+			return this.InternalToAggregateAsync<TReturn>(select?.Body);
+		}
+
+		List<TReturn> ISelect<T1, T2>.ToList<TReturn>(Expression<Func<T1, T2, TReturn>> select) {
+			if (select == null) return this.InternalToList<TReturn>(select?.Body);
+			for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
+			return this.InternalToList<TReturn>(select?.Body);
+		}
+
+		Task<List<TReturn>> ISelect<T1, T2>.ToListAsync<TReturn>(Expression<Func<T1, T2, TReturn>> select) {
+			if (select == null) return this.InternalToListAsync<TReturn>(select?.Body);
+			for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
+			return this.InternalToListAsync<TReturn>(select?.Body);
+		}
+
+		DataTable ISelect<T1, T2>.ToDataTable<TReturn>(Expression<Func<T1, T2, TReturn>> select) {
+			if (select == null) return this.InternalToDataTable(select?.Body);
+			for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
+			return this.InternalToDataTable(select?.Body);
+		}
+
+		Task<DataTable> ISelect<T1, T2>.ToDataTableAsync<TReturn>(Expression<Func<T1, T2, TReturn>> select) {
+			if (select == null) return this.InternalToDataTableAsync(select?.Body);
+			for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
+			return this.InternalToDataTableAsync(select?.Body);
+		}
+
+		string ISelect<T1, T2>.ToSql<TReturn>(Expression<Func<T1, T2, TReturn>> select) {
+			if (select == null) return this.InternalToSql<TReturn>(select?.Body);
+			for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
+			return this.InternalToSql<TReturn>(select?.Body);
+		}
+
+		ISelect<T1, T2> ISelect<T1, T2>.Where(Expression<Func<T1, T2, bool>> exp) {
+			if (exp == null) return this.Where(null);
+			for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
+			return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
+		}
+
+		ISelect<T1, T2> ISelect<T1, T2>.WhereIf(bool condition, Expression<Func<T1, T2, bool>> exp) {
+			if (condition) return this.Where(null);
+			if (exp == null) return this.Where(null);
+			for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
+			return condition ? this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)) : this;
+		}
+
+		bool ISelect<T1, T2>.Any(Expression<Func<T1, T2, bool>> exp) {
+			if (exp == null) return this.Any();
+			for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
+			return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).Any();
+		}
+
+		Task<bool> ISelect<T1, T2>.AnyAsync(Expression<Func<T1, T2, bool>> exp) {
+			if (exp == null) return this.AnyAsync();
+			for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
+			return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).AnyAsync();
+		}
+	}
+}
--- a/FreeSql/Internal/UtilsExpressionTree.cs
+++ b/FreeSql/Internal/UtilsExpressionTree.cs
@ -385,7 +385,7 @@ namespace FreeSql.Internal {
 						}

 						if (isLazy) {
-							cscode.Append("	public bool __lazy__").Append(pnv.Name).AppendLine(" = false;")
+							cscode.Append("	private bool __lazy__").Append(pnv.Name).AppendLine(" = false;")
 									.Append("	public override ").Append(propTypeName).Append(" ").Append(pnv.Name).AppendLine(" {");
 							if (vp.Item2) { //get 重写
 								cscode.Append("		get {\r\n")
@ -460,7 +460,7 @@ namespace FreeSql.Internal {
 						}

 						if (isLazy) {
-							cscode.Append("	public bool __lazy__").Append(pnv.Name).AppendLine(" = false;")
+							cscode.Append("	private bool __lazy__").Append(pnv.Name).AppendLine(" = false;")
 								.Append("	public override ").Append(propTypeName).Append(" ").Append(pnv.Name).AppendLine(" {");
 							if (vp.Item2) { //get 重写
 								cscode.Append("		get {\r\n")
@ -550,7 +550,7 @@ namespace FreeSql.Internal {
 					}

 					if (isLazy) {
-						cscode.Append("	public bool __lazy__").Append(pnv.Name).AppendLine(" = false;")
+						cscode.Append("	private bool __lazy__").Append(pnv.Name).AppendLine(" = false;")
 							.Append("	public override ").Append(propTypeName).Append(" ").Append(pnv.Name).AppendLine(" {");
 						if (vp.Item2) { //get 重写
 							cscode.Append("		get {\r\n")
@ -1009,6 +1009,17 @@ namespace FreeSql.Internal {
 		static MethodInfo MethodJTokenParse = typeof(JToken).GetMethod("Parse", new[] { typeof(string) });
 		static MethodInfo MethodJObjectParse = typeof(JObject).GetMethod("Parse", new[] { typeof(string) });
 		static MethodInfo MethodJArrayParse = typeof(JArray).GetMethod("Parse", new[] { typeof(string) });
+		static MethodInfo MethodSByteTryParse = typeof(sbyte).GetMethod("TryParse", new[] { typeof(string), typeof(sbyte).MakeByRefType() });
+		static MethodInfo MethodShortTryParse = typeof(short).GetMethod("TryParse", new[] { typeof(string), typeof(short).MakeByRefType() });
+		static MethodInfo MethodIntTryParse = typeof(int).GetMethod("TryParse", new[] { typeof(string), typeof(int).MakeByRefType() });
+		static MethodInfo MethodLongTryParse = typeof(long).GetMethod("TryParse", new[] { typeof(string), typeof(long).MakeByRefType() });
+		static MethodInfo MethodByteTryParse = typeof(byte).GetMethod("TryParse", new[] { typeof(string), typeof(byte).MakeByRefType() });
+		static MethodInfo MethodUShortTryParse = typeof(ushort).GetMethod("TryParse", new[] { typeof(string), typeof(ushort).MakeByRefType() });
+		static MethodInfo MethodUIntTryParse = typeof(uint).GetMethod("TryParse", new[] { typeof(string), typeof(uint).MakeByRefType() });
+		static MethodInfo MethodULongTryParse = typeof(ulong).GetMethod("TryParse", new[] { typeof(string), typeof(ulong).MakeByRefType() });
+		static MethodInfo MethodDoubleTryParse = typeof(double).GetMethod("TryParse", new[] { typeof(string), typeof(double).MakeByRefType() });
+		static MethodInfo MethodFloatTryParse = typeof(float).GetMethod("TryParse", new[] { typeof(string), typeof(float).MakeByRefType() });
+		static MethodInfo MethodDecimalTryParse = typeof(decimal).GetMethod("TryParse", new[] { typeof(string), typeof(decimal).MakeByRefType() });
 		public static Expression GetDataReaderValueBlockExpression(Type type, Expression value) {
 			var returnTarget = Expression.Label(typeof(object));
 			var valueExp = Expression.Variable(typeof(object), "locvalue");
@ -1024,7 +1035,7 @@ namespace FreeSql.Internal {
 					var label = Expression.Label(typeof(int));
 					return Expression.IfThenElse(
 						Expression.TypeEqual(valueExp, type),
-						Expression.Return(returnTarget, valueExp), 
+						Expression.Return(returnTarget, valueExp),
 						Expression.Block(
 							new[] { arrNewExp, arrExp, arrLenExp, arrXExp, arrReadValExp },
 							Expression.Assign(arrExp, Expression.TypeAs(valueExp, typeof(Array))),
@ -1051,10 +1062,15 @@ namespace FreeSql.Internal {
 						)
 					);
 				}
+				var typeOrg = type;
 				if (type.IsNullableType()) type = type.GenericTypeArguments.First();
 				if (type.IsEnum) return Expression.Return(returnTarget, Expression.Call(MethodEnumParse, Expression.Constant(type, typeof(Type)), Expression.Call(MethodToString, valueExp), Expression.Constant(true, typeof(bool))));
-				switch(type.FullName) {
-					case "System.Guid": return Expression.IfThenElse(
+				Expression tryparseExp = null;
+				Expression tryparseBooleanExp = null;
+				ParameterExpression tryparseVarExp = null;
+				switch (type.FullName) {
+					case "System.Guid":
+						return Expression.IfThenElse(
 							Expression.TypeEqual(valueExp, type),
 							Expression.Return(returnTarget, valueExp),
 							Expression.Return(returnTarget, Expression.Convert(Expression.Call(MethodGuidParse, Expression.Convert(valueExp, typeof(string))), typeof(object)))
@ -1069,22 +1085,190 @@ namespace FreeSql.Internal {
 					case "Newtonsoft.Json.Linq.JObject": return Expression.Return(returnTarget, Expression.TypeAs(Expression.Call(MethodJObjectParse, Expression.Convert(valueExp, typeof(string))), typeof(JObject)));
 					case "Newtonsoft.Json.Linq.JArray": return Expression.Return(returnTarget, Expression.TypeAs(Expression.Call(MethodJArrayParse, Expression.Convert(valueExp, typeof(string))), typeof(JArray)));
 					case "Npgsql.LegacyPostgis.PostgisGeometry": return Expression.Return(returnTarget, valueExp);
-					case "System.TimeSpan": return Expression.IfThenElse(
+					case "System.TimeSpan":
+						return Expression.IfThenElse(
 							Expression.TypeEqual(valueExp, type),
 							Expression.Return(returnTarget, valueExp),
 							Expression.Return(returnTarget, Expression.Convert(Expression.Call(MethodTimeSpanFromSeconds, Expression.Call(MethodDoubleParse, Expression.Call(MethodToString, valueExp))), typeof(object)))
 						);
+					case "System.SByte":
+						tryparseExp = Expression.Block(
+						   new[] { tryparseVarExp = Expression.Variable(typeof(sbyte)) },
+						   new Expression[] {
+								Expression.IfThenElse(
+									Expression.IsTrue(Expression.Call(MethodSByteTryParse, Expression.Convert(valueExp, typeof(string)), tryparseVarExp)),
+									Expression.Return(returnTarget, Expression.Convert(tryparseVarExp, typeof(object))),
+									Expression.Return(returnTarget, Expression.Convert(Expression.Default(typeOrg), typeof(object)))
+								)
+							   }
+						   );
+						break;
+					case "System.Int16":
+						tryparseExp = Expression.Block(
+							  new[] { tryparseVarExp = Expression.Variable(typeof(short)) },
+							   new Expression[] {
+								Expression.IfThenElse(
+									Expression.IsTrue(Expression.Call(MethodShortTryParse, Expression.Convert(valueExp, typeof(string)), tryparseVarExp)),
+									Expression.Return(returnTarget, Expression.Convert(tryparseVarExp, typeof(object))),
+									Expression.Return(returnTarget, Expression.Convert(Expression.Default(typeOrg), typeof(object)))
+								)
+							   }
+						   );
+						break;
+					case "System.Int32":
+						tryparseExp = Expression.Block(
+							  new[] { tryparseVarExp = Expression.Variable(typeof(int)) },
+							   new Expression[] {
+								Expression.IfThenElse(
+									Expression.IsTrue(Expression.Call(MethodIntTryParse, Expression.Convert(valueExp, typeof(string)), tryparseVarExp)),
+									Expression.Return(returnTarget, Expression.Convert(tryparseVarExp, typeof(object))),
+									Expression.Return(returnTarget, Expression.Convert(Expression.Default(typeOrg), typeof(object)))
+								)
+							   }
+						   );
+						break;
+					case "System.Int64":
+						tryparseExp = Expression.Block(
+							  new[] { tryparseVarExp = Expression.Variable(typeof(long)) },
+							   new Expression[] {
+								Expression.IfThenElse(
+									Expression.IsTrue(Expression.Call(MethodLongTryParse, Expression.Convert(valueExp, typeof(string)), tryparseVarExp)),
+									Expression.Return(returnTarget, Expression.Convert(tryparseVarExp, typeof(object))),
+									Expression.Return(returnTarget, Expression.Convert(Expression.Default(typeOrg), typeof(object)))
+								)
+							   }
+						   );
+						break;
+					case "System.Byte":
+						tryparseExp = Expression.Block(
+							  new[] { tryparseVarExp = Expression.Variable(typeof(byte)) },
+							   new Expression[] {
+								Expression.IfThenElse(
+									Expression.IsTrue(Expression.Call(MethodByteTryParse, Expression.Convert(valueExp, typeof(string)), tryparseVarExp)),
+									Expression.Return(returnTarget, Expression.Convert(tryparseVarExp, typeof(object))),
+									Expression.Return(returnTarget, Expression.Convert(Expression.Default(typeOrg), typeof(object)))
+								)
+							   }
+						   );
+						break;
+					case "System.UInt16":
+						tryparseExp = Expression.Block(
+							   new[] { tryparseVarExp = Expression.Variable(typeof(ushort)) },
+							   new Expression[] {
+								Expression.IfThenElse(
+									Expression.IsTrue(Expression.Call(MethodUShortTryParse, Expression.Convert(valueExp, typeof(string)), tryparseVarExp)),
+									Expression.Return(returnTarget, Expression.Convert(tryparseVarExp, typeof(object))),
+									Expression.Return(returnTarget, Expression.Convert(Expression.Default(typeOrg), typeof(object)))
+								)
+							   }
+						   );
+						break;
+					case "System.UInt32":
+						tryparseExp = Expression.Block(
+							   new[] { tryparseVarExp = Expression.Variable(typeof(uint)) },
+							   new Expression[] {
+								Expression.IfThenElse(
+									Expression.IsTrue(Expression.Call(MethodUIntTryParse, Expression.Convert(valueExp, typeof(string)), tryparseVarExp)),
+									Expression.Return(returnTarget, Expression.Convert(tryparseVarExp, typeof(object))),
+									Expression.Return(returnTarget, Expression.Convert(Expression.Default(typeOrg), typeof(object)))
+								)
+							   }
+						   );
+						break;
+					case "System.UInt64":
+						tryparseExp = Expression.Block(
+							  new[] { tryparseVarExp = Expression.Variable(typeof(ulong)) },
+							   new Expression[] {
+								Expression.IfThenElse(
+									Expression.IsTrue(Expression.Call(MethodULongTryParse, Expression.Convert(valueExp, typeof(string)), tryparseVarExp)),
+									Expression.Return(returnTarget, Expression.Convert(tryparseVarExp, typeof(object))),
+									Expression.Return(returnTarget, Expression.Convert(Expression.Default(typeOrg), typeof(object)))
+								)
+							   }
+						   );
+						break;
+					case "System.Single":
+						tryparseExp = Expression.Block(
+							  new[] { tryparseVarExp = Expression.Variable(typeof(float)) },
+							   new Expression[] {
+								Expression.IfThenElse(
+									Expression.IsTrue(Expression.Call(MethodFloatTryParse, Expression.Convert(valueExp, typeof(string)), tryparseVarExp)),
+									Expression.Return(returnTarget, Expression.Convert(tryparseVarExp, typeof(object))),
+									Expression.Return(returnTarget, Expression.Convert(Expression.Default(typeOrg), typeof(object)))
+								)
+							   }
+						   );
+						break;
+					case "System.Double":
+						tryparseExp = Expression.Block(
+							   new[] { tryparseVarExp = Expression.Variable(typeof(double)) },
+							   new Expression[] {
+								Expression.IfThenElse(
+									Expression.IsTrue(Expression.Call(MethodDoubleTryParse, Expression.Convert(valueExp, typeof(string)), tryparseVarExp)),
+									Expression.Return(returnTarget, Expression.Convert(tryparseVarExp, typeof(object))),
+									Expression.Return(returnTarget, Expression.Convert(Expression.Default(typeOrg), typeof(object)))
+								)
+							   }
+						   );
+						break;
+					case "System.Decimal":
+						tryparseExp = Expression.Block(
+							  new[] { tryparseVarExp = Expression.Variable(typeof(decimal)) },
+							   new Expression[] {
+								Expression.IfThenElse(
+									Expression.IsTrue(Expression.Call(MethodDecimalTryParse, Expression.Convert(valueExp, typeof(string)), tryparseVarExp)),
+									Expression.Return(returnTarget, Expression.Convert(tryparseVarExp, typeof(object))),
+									Expression.Return(returnTarget, Expression.Convert(Expression.Default(typeOrg), typeof(object)))
+								)
+							   }
+						   );
+						break;
+					case "System.Boolean":
+						tryparseBooleanExp = Expression.Return(returnTarget,
+								Expression.Convert(
+									Expression.Not(
+										Expression.Or(
+											Expression.Equal(Expression.Convert(valueExp, typeof(string)), Expression.Constant("False")),
+										Expression.Or(
+											Expression.Equal(Expression.Convert(valueExp, typeof(string)), Expression.Constant("false")),
+											Expression.Equal(Expression.Convert(valueExp, typeof(string)), Expression.Constant("0"))))),
+							typeof(object))
+						);
+						break;
 				}
+				Expression switchExp = null;
+				if (tryparseExp != null)
+					switchExp = Expression.Switch(
+						Expression.Constant(type),
+						Expression.SwitchCase(tryparseExp,
+							Expression.Constant(typeof(sbyte)), Expression.Constant(typeof(short)), Expression.Constant(typeof(int)), Expression.Constant(typeof(long)),
+							Expression.Constant(typeof(byte)), Expression.Constant(typeof(ushort)), Expression.Constant(typeof(uint)), Expression.Constant(typeof(ulong)),
+							Expression.Constant(typeof(double)), Expression.Constant(typeof(float)), Expression.Constant(typeof(decimal))),
+						Expression.SwitchCase(Expression.Return(returnTarget, Expression.Call(MethodConvertChangeType, valueExp, Expression.Constant(type, typeof(Type)))), Expression.Constant(type))
+					);
+				else if (tryparseBooleanExp != null)
+					switchExp = Expression.Switch(
+						Expression.Constant(type),
+						Expression.SwitchCase(tryparseBooleanExp, Expression.Constant(typeof(bool))),
+						Expression.SwitchCase(Expression.Return(returnTarget, Expression.Call(MethodConvertChangeType, valueExp, Expression.Constant(type, typeof(Type)))), Expression.Constant(type))
+					);
+				else
+					switchExp = Expression.Return(returnTarget, Expression.Call(MethodConvertChangeType, valueExp, Expression.Constant(type, typeof(Type))));
+
 				return Expression.IfThenElse(
 					Expression.TypeEqual(valueExp, type),
 					Expression.Return(returnTarget, valueExp),
-					Expression.Return(returnTarget, Expression.Call(MethodConvertChangeType, valueExp, Expression.Constant(type, typeof(Type))))
+					Expression.IfThenElse(
+						Expression.TypeEqual(valueExp, typeof(string)),
+						switchExp,
+						Expression.Return(returnTarget, Expression.Call(MethodConvertChangeType, valueExp, Expression.Constant(type, typeof(Type))))
+					)
 				);
 			};

 			return Expression.Block(
 				new[] { valueExp },
-				Expression.Assign(valueExp, value),
+				Expression.Assign(valueExp, Expression.Convert(value, typeof(object))),
 				Expression.IfThenElse(
 					Expression.Or(
 						Expression.Equal(valueExp, Expression.Constant(null)),
@ -1097,9 +1281,9 @@ namespace FreeSql.Internal {
 			);
 		}
 		public static object GetDataReaderValue(Type type, object value) {
-			if (value == null || value == DBNull.Value) return null;
+			//if (value == null || value == DBNull.Value) return Activator.CreateInstance(type);
 			if (type == null) return value;
-			var func = _dicGetDataReaderValue.GetOrAdd(type, k1 => new ConcurrentDictionary<Type, Func<object, object>>()).GetOrAdd(value.GetType(), valueType => {
+			var func = _dicGetDataReaderValue.GetOrAdd(type, k1 => new ConcurrentDictionary<Type, Func<object, object>>()).GetOrAdd(value?.GetType() ?? type, valueType => {
 				var parmExp = Expression.Parameter(typeof(object), "value");
 				var exp = GetDataReaderValueBlockExpression(type, parmExp);
 				return Expression.Lambda<Func<object, object>>(exp, parmExp).Compile();
@ -1233,7 +1417,7 @@ namespace FreeSql.Internal {
 			#endregion
 		}
 		internal static object GetDataReaderValue22(Type type, object value) {
-			if (value == null || value == DBNull.Value) return null;
+			if (value == null || value == DBNull.Value) return Activator.CreateInstance(type);
 			if (type.FullName == "System.Byte[]") return value;
 			if (type.IsArray) {
 				var elementType = type.GetElementType();
--- a/FreeSql/MySql/Curd/MySqlSelect.cs
+++ b/FreeSql/MySql/Curd/MySqlSelect.cs
@ -78,6 +78,7 @@ namespace FreeSql.MySql.Curd {
 		}

 		public MySqlSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
+		public override ISelect<T1, T2> From<T2>(Expression<Func<ISelectFromExpression<T1>, T2, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new MySqlSelect<T1, T2>(_orm, _commonUtils, _commonExpression, null); MySqlSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
 		public override ISelect<T1, T2, T3> From<T2, T3>(Expression<Func<ISelectFromExpression<T1>, T2, T3, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new MySqlSelect<T1, T2, T3>(_orm, _commonUtils, _commonExpression, null); MySqlSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
 		public override ISelect<T1, T2, T3, T4> From<T2, T3, T4>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new MySqlSelect<T1, T2, T3, T4>(_orm, _commonUtils, _commonExpression, null); MySqlSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
 		public override ISelect<T1, T2, T3, T4, T5> From<T2, T3, T4, T5>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, T5, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new MySqlSelect<T1, T2, T3, T4, T5>(_orm, _commonUtils, _commonExpression, null); MySqlSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
@ -88,6 +89,10 @@ namespace FreeSql.MySql.Curd {
 		public override ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> From<T2, T3, T4, T5, T6, T7, T8, T9, T10>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new MySqlSelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(_orm, _commonUtils, _commonExpression, null); MySqlSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
 		public override string ToSql(string field = null) => ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllFieldExpressionTree().Field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRuleInvoke, _orm);
 	}
+	class MySqlSelect<T1, T2> : FreeSql.Internal.CommonProvider.Select2Provider<T1, T2> where T1 : class where T2 : class {
+		public MySqlSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
+		public override string ToSql(string field = null) => MySqlSelect<T1>.ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllFieldExpressionTree().Field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRuleInvoke, _orm);
+	}
 	class MySqlSelect<T1, T2, T3> : FreeSql.Internal.CommonProvider.Select3Provider<T1, T2, T3> where T1 : class where T2 : class where T3 : class {
 		public MySqlSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
 		public override string ToSql(string field = null) => MySqlSelect<T1>.ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllFieldExpressionTree().Field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRuleInvoke, _orm);
--- a/FreeSql/Oracle/Curd/OracleSelect.cs
+++ b/FreeSql/Oracle/Curd/OracleSelect.cs
@ -90,6 +90,7 @@ namespace FreeSql.Oracle.Curd {
 		}

 		public OracleSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
+		public override ISelect<T1, T2> From<T2>(Expression<Func<ISelectFromExpression<T1>, T2, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new OracleSelect<T1, T2>(_orm, _commonUtils, _commonExpression, null); OracleSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
 		public override ISelect<T1, T2, T3> From<T2, T3>(Expression<Func<ISelectFromExpression<T1>, T2, T3, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new OracleSelect<T1, T2, T3>(_orm, _commonUtils, _commonExpression, null); OracleSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
 		public override ISelect<T1, T2, T3, T4> From<T2, T3, T4>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new OracleSelect<T1, T2, T3, T4>(_orm, _commonUtils, _commonExpression, null); OracleSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
 		public override ISelect<T1, T2, T3, T4, T5> From<T2, T3, T4, T5>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, T5, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new OracleSelect<T1, T2, T3, T4, T5>(_orm, _commonUtils, _commonExpression, null); OracleSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
@ -100,6 +101,10 @@ namespace FreeSql.Oracle.Curd {
 		public override ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> From<T2, T3, T4, T5, T6, T7, T8, T9, T10>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new OracleSelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(_orm, _commonUtils, _commonExpression, null); OracleSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
 		public override string ToSql(string field = null) => ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllFieldExpressionTree().Field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRuleInvoke, _orm);
 	}
+	class OracleSelect<T1, T2> : FreeSql.Internal.CommonProvider.Select2Provider<T1, T2> where T1 : class where T2 : class {
+		public OracleSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
+		public override string ToSql(string field = null) => OracleSelect<T1>.ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllFieldExpressionTree().Field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRuleInvoke, _orm);
+	}
 	class OracleSelect<T1, T2, T3> : FreeSql.Internal.CommonProvider.Select3Provider<T1, T2, T3> where T1 : class where T2 : class where T3 : class {
 		public OracleSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
 		public override string ToSql(string field = null) => OracleSelect<T1>.ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllFieldExpressionTree().Field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRuleInvoke, _orm);
--- a/FreeSql/PostgreSQL/Curd/PostgreSQLSelect.cs
+++ b/FreeSql/PostgreSQL/Curd/PostgreSQLSelect.cs
@ -80,6 +80,7 @@ namespace FreeSql.PostgreSQL.Curd {
 		}

 		public PostgreSQLSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
+		public override ISelect<T1, T2> From<T2>(Expression<Func<ISelectFromExpression<T1>, T2, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new PostgreSQLSelect<T1, T2>(_orm, _commonUtils, _commonExpression, null); PostgreSQLSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
 		public override ISelect<T1, T2, T3> From<T2, T3>(Expression<Func<ISelectFromExpression<T1>, T2, T3, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new PostgreSQLSelect<T1, T2, T3>(_orm, _commonUtils, _commonExpression, null); PostgreSQLSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
 		public override ISelect<T1, T2, T3, T4> From<T2, T3, T4>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new PostgreSQLSelect<T1, T2, T3, T4>(_orm, _commonUtils, _commonExpression, null); PostgreSQLSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
 		public override ISelect<T1, T2, T3, T4, T5> From<T2, T3, T4, T5>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, T5, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new PostgreSQLSelect<T1, T2, T3, T4, T5>(_orm, _commonUtils, _commonExpression, null); PostgreSQLSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
@ -90,10 +91,10 @@ namespace FreeSql.PostgreSQL.Curd {
 		public override ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> From<T2, T3, T4, T5, T6, T7, T8, T9, T10>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new PostgreSQLSelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(_orm, _commonUtils, _commonExpression, null); PostgreSQLSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
 		public override string ToSql(string field = null) => ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllFieldExpressionTree().Field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRuleInvoke, _orm);
 	}
-	//class PostgreSQLSelect<T1, T2> : FreeSql.Internal.CommonProvider.Select2Provider<T1, T2> where T1 : class where T2 : class {
-	//	public PostgreSQLSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
-	//	public override string ToSql(string field = null) => PostgreSQLSelect<T1>.ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllField().field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRulesInvoke, _orm);
-	//}
+	class PostgreSQLSelect<T1, T2> : FreeSql.Internal.CommonProvider.Select2Provider<T1, T2> where T1 : class where T2 : class {
+		public PostgreSQLSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
+		public override string ToSql(string field = null) => PostgreSQLSelect<T1>.ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllFieldExpressionTree().Field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRuleInvoke, _orm);
+	}
 	class PostgreSQLSelect<T1, T2, T3> : FreeSql.Internal.CommonProvider.Select3Provider<T1, T2, T3> where T1 : class where T2 : class where T3 : class {
 		public PostgreSQLSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
 		public override string ToSql(string field = null) => PostgreSQLSelect<T1>.ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllFieldExpressionTree().Field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRuleInvoke, _orm);
--- a/FreeSql/SqlServer/Curd/SqlServerSelect.cs
+++ b/FreeSql/SqlServer/Curd/SqlServerSelect.cs
@ -175,6 +175,7 @@ namespace FreeSql.SqlServer.Curd {
 		#endregion

 		public SqlServerSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
+		public override ISelect<T1, T2> From<T2>(Expression<Func<ISelectFromExpression<T1>, T2, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new SqlServerSelect<T1, T2>(_orm, _commonUtils, _commonExpression, null); SqlServerSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
 		public override ISelect<T1, T2, T3> From<T2, T3>(Expression<Func<ISelectFromExpression<T1>, T2, T3, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new SqlServerSelect<T1, T2, T3>(_orm, _commonUtils, _commonExpression, null); SqlServerSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
 		public override ISelect<T1, T2, T3, T4> From<T2, T3, T4>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new SqlServerSelect<T1, T2, T3, T4>(_orm, _commonUtils, _commonExpression, null); SqlServerSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
 		public override ISelect<T1, T2, T3, T4, T5> From<T2, T3, T4, T5>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, T5, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new SqlServerSelect<T1, T2, T3, T4, T5>(_orm, _commonUtils, _commonExpression, null); SqlServerSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
@ -185,10 +186,10 @@ namespace FreeSql.SqlServer.Curd {
 		public override ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> From<T2, T3, T4, T5, T6, T7, T8, T9, T10>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new SqlServerSelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(_orm, _commonUtils, _commonExpression, null); SqlServerSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
 		public override string ToSql(string field = null) => ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllFieldExpressionTree().Field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRuleInvoke, _orm);
 	}
-	//class SqlServerSelect<T1, T2> : FreeSql.Internal.CommonProvider.Select2Provider<T1, T2> where T1 : class where T2 : class {
-	//	public SqlServerSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
-	//	public override string ToSql(string field = null) => SqlServerSelect<T1>.ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllField().field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRulesInvoke, _orm);
-	//}
+	class SqlServerSelect<T1, T2> : FreeSql.Internal.CommonProvider.Select2Provider<T1, T2> where T1 : class where T2 : class {
+		public SqlServerSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
+		public override string ToSql(string field = null) => SqlServerSelect<T1>.ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllFieldExpressionTree().Field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRuleInvoke, _orm);
+	}
 	class SqlServerSelect<T1, T2, T3> : FreeSql.Internal.CommonProvider.Select3Provider<T1, T2, T3> where T1 : class where T2 : class where T3 : class {
 		public SqlServerSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
 		public override string ToSql(string field = null) => SqlServerSelect<T1>.ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllFieldExpressionTree().Field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRuleInvoke, _orm);
--- a/FreeSql/Sqlite/Curd/SqliteSelect.cs
+++ b/FreeSql/Sqlite/Curd/SqliteSelect.cs
@ -78,6 +78,7 @@ namespace FreeSql.Sqlite.Curd {
 		}

 		public SqliteSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
+		public override ISelect<T1, T2> From<T2>(Expression<Func<ISelectFromExpression<T1>, T2, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new SqliteSelect<T1, T2>(_orm, _commonUtils, _commonExpression, null); SqliteSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
 		public override ISelect<T1, T2, T3> From<T2, T3>(Expression<Func<ISelectFromExpression<T1>, T2, T3, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new SqliteSelect<T1, T2, T3>(_orm, _commonUtils, _commonExpression, null); SqliteSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
 		public override ISelect<T1, T2, T3, T4> From<T2, T3, T4>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new SqliteSelect<T1, T2, T3, T4>(_orm, _commonUtils, _commonExpression, null); SqliteSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
 		public override ISelect<T1, T2, T3, T4, T5> From<T2, T3, T4, T5>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, T5, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new SqliteSelect<T1, T2, T3, T4, T5>(_orm, _commonUtils, _commonExpression, null); SqliteSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
@ -88,6 +89,10 @@ namespace FreeSql.Sqlite.Curd {
 		public override ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> From<T2, T3, T4, T5, T6, T7, T8, T9, T10>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new SqliteSelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(_orm, _commonUtils, _commonExpression, null); SqliteSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
 		public override string ToSql(string field = null) => ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllFieldExpressionTree().Field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRuleInvoke, _orm);
 	}
+	class SqliteSelect<T1, T2> : FreeSql.Internal.CommonProvider.Select2Provider<T1, T2> where T1 : class where T2 : class {
+		public SqliteSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
+		public override string ToSql(string field = null) => SqliteSelect<T1>.ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllFieldExpressionTree().Field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRuleInvoke, _orm);
+	}
 	class SqliteSelect<T1, T2, T3> : FreeSql.Internal.CommonProvider.Select3Provider<T1, T2, T3> where T1 : class where T2 : class where T3 : class {
 		public SqliteSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
 		public override string ToSql(string field = null) => SqliteSelect<T1>.ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllFieldExpressionTree().Field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRuleInvoke, _orm);