## v0.4.16

- 增加 ISelect.AsType 实现弱类型查询，配合 Select<object>().AsType(实体类型)；
- 补充 ISelect.From<T2>；
- 补充 ExpressionTree 单元测试；
- 优化 ToList(a => new Dto())，会按优先级查询 Join 实体属性；

FreeSql.Tests/ExpressionTree/GetDataReaderValueBlockExpressionTest.cs

@@ -0,0 +1,346 @@
+using FreeSql.DataAnnotations;
+using FreeSql;
+using System;
+using System.Collections.Generic;
+using Xunit;
+using System.Linq;
+using Newtonsoft.Json.Linq;
+using NpgsqlTypes;
+using Npgsql.LegacyPostgis;
+using FreeSql.Internal;
+using System.Linq.Expressions;
+
+namespace FreeSql.ExpressionTree {
+	public class GetDataReaderValueBlockExpressionTest {
+
+		[Fact]
+		public void Boolean() {
+			var exp1 = Utils.GetDataReaderValueBlockExpression(typeof(bool), Expression.Constant(true));
+			Assert.Equal(true, Utils.GetDataReaderValue(typeof(bool), true));
+			var exp2 = Utils.GetDataReaderValueBlockExpression(typeof(bool), Expression.Constant(false));
+			Assert.Equal(false, Utils.GetDataReaderValue(typeof(bool), false));
+			var exp3 = Utils.GetDataReaderValueBlockExpression(typeof(bool), Expression.Constant(null));
+			Assert.Equal(false, Utils.GetDataReaderValue(typeof(bool), null));
+
+			var exp11 = Utils.GetDataReaderValueBlockExpression(typeof(bool?), Expression.Constant(true));
+			Assert.Equal(true, Utils.GetDataReaderValue(typeof(bool?), true));
+			var exp22 = Utils.GetDataReaderValueBlockExpression(typeof(bool?), Expression.Constant(false));
+			Assert.Equal(false, Utils.GetDataReaderValue(typeof(bool?), false));
+			var exp33 = Utils.GetDataReaderValueBlockExpression(typeof(bool?), Expression.Constant(null));
+			Assert.Null(Utils.GetDataReaderValue(typeof(bool?), null));
+
+			var exp111 = Utils.GetDataReaderValueBlockExpression(typeof(bool), Expression.Constant("1"));
+			Assert.Equal(true, Utils.GetDataReaderValue(typeof(bool), true));
+			var exp222 = Utils.GetDataReaderValueBlockExpression(typeof(bool), Expression.Constant("0"));
+			Assert.Equal(false, Utils.GetDataReaderValue(typeof(bool), false));
+			var exp333 = Utils.GetDataReaderValueBlockExpression(typeof(bool), Expression.Constant("-1"));
+			Assert.Equal(true, Utils.GetDataReaderValue(typeof(bool), true));
+
+			var exp1111 = Utils.GetDataReaderValueBlockExpression(typeof(bool), Expression.Constant("true"));
+			Assert.Equal(true, Utils.GetDataReaderValue(typeof(bool?), true));
+			var exp2222 = Utils.GetDataReaderValueBlockExpression(typeof(bool), Expression.Constant("True"));
+			Assert.Equal(true, Utils.GetDataReaderValue(typeof(bool?), true));
+			var exp3333 = Utils.GetDataReaderValueBlockExpression(typeof(bool), Expression.Constant("false"));
+			Assert.Equal(false, Utils.GetDataReaderValue(typeof(bool?), false));
+			var exp4444 = Utils.GetDataReaderValueBlockExpression(typeof(bool), Expression.Constant("False"));
+			Assert.Equal(false, Utils.GetDataReaderValue(typeof(bool?), false));
+		}
+
+		[Fact]
+		public void SByte() {
+			var exp1 = Utils.GetDataReaderValueBlockExpression(typeof(sbyte), Expression.Constant(sbyte.MinValue));
+			Assert.Equal(sbyte.MinValue, Utils.GetDataReaderValue(typeof(sbyte), sbyte.MinValue));
+			var exp2 = Utils.GetDataReaderValueBlockExpression(typeof(sbyte), Expression.Constant(sbyte.MaxValue));
+			Assert.Equal(sbyte.MaxValue, Utils.GetDataReaderValue(typeof(sbyte), sbyte.MaxValue));
+			var exp3 = Utils.GetDataReaderValueBlockExpression(typeof(sbyte), Expression.Constant("127"));
+			Assert.Equal((sbyte)127, Utils.GetDataReaderValue(typeof(sbyte), "127"));
+
+			var exp11 = Utils.GetDataReaderValueBlockExpression(typeof(sbyte?), Expression.Constant(sbyte.MinValue));
+			Assert.Equal(sbyte.MinValue, Utils.GetDataReaderValue(typeof(sbyte?), sbyte.MinValue));
+			var exp22 = Utils.GetDataReaderValueBlockExpression(typeof(sbyte?), Expression.Constant(sbyte.MaxValue));
+			Assert.Equal(sbyte.MaxValue, Utils.GetDataReaderValue(typeof(sbyte?), sbyte.MaxValue));
+			var exp33 = Utils.GetDataReaderValueBlockExpression(typeof(sbyte?), Expression.Constant("127"));
+			Assert.Equal((sbyte)127, Utils.GetDataReaderValue(typeof(sbyte?), "127"));
+
+			var exp111 = Utils.GetDataReaderValueBlockExpression(typeof(sbyte), Expression.Constant(null));
+			Assert.Equal(default(sbyte), Utils.GetDataReaderValue(typeof(sbyte), null));
+			var exp222 = Utils.GetDataReaderValueBlockExpression(typeof(sbyte), Expression.Constant("aaa"));
+			Assert.Equal(default(sbyte), Utils.GetDataReaderValue(typeof(sbyte), "aaa"));
+
+			var exp1111 = Utils.GetDataReaderValueBlockExpression(typeof(sbyte?), Expression.Constant(null));
+			Assert.Null(Utils.GetDataReaderValue(typeof(sbyte?), null));
+			var exp2222 = Utils.GetDataReaderValueBlockExpression(typeof(sbyte?), Expression.Constant("aaa"));
+			Assert.Null(Utils.GetDataReaderValue(typeof(sbyte?), "aaa"));
+		}
+
+		[Fact]
+		public void Short() {
+			var exp1 = Utils.GetDataReaderValueBlockExpression(typeof(short), Expression.Constant(short.MinValue));
+			Assert.Equal(short.MinValue, Utils.GetDataReaderValue(typeof(short), short.MinValue));
+			var exp2 = Utils.GetDataReaderValueBlockExpression(typeof(short), Expression.Constant(short.MaxValue));
+			Assert.Equal(short.MaxValue, Utils.GetDataReaderValue(typeof(short), short.MaxValue));
+			var exp3 = Utils.GetDataReaderValueBlockExpression(typeof(short), Expression.Constant("127"));
+			Assert.Equal((short)127, Utils.GetDataReaderValue(typeof(short), "127"));
+
+			var exp11 = Utils.GetDataReaderValueBlockExpression(typeof(short?), Expression.Constant(short.MinValue));
+			Assert.Equal(short.MinValue, Utils.GetDataReaderValue(typeof(short?), short.MinValue));
+			var exp22 = Utils.GetDataReaderValueBlockExpression(typeof(short?), Expression.Constant(short.MaxValue));
+			Assert.Equal(short.MaxValue, Utils.GetDataReaderValue(typeof(short?), short.MaxValue));
+			var exp33 = Utils.GetDataReaderValueBlockExpression(typeof(short?), Expression.Constant("127"));
+			Assert.Equal((short)127, Utils.GetDataReaderValue(typeof(short?), "127"));
+
+			var exp111 = Utils.GetDataReaderValueBlockExpression(typeof(short), Expression.Constant(null));
+			Assert.Equal(default(short), Utils.GetDataReaderValue(typeof(short), null));
+			var exp222 = Utils.GetDataReaderValueBlockExpression(typeof(short), Expression.Constant("aaa"));
+			Assert.Equal(default(short), Utils.GetDataReaderValue(typeof(short), "aaa"));
+
+			var exp1111 = Utils.GetDataReaderValueBlockExpression(typeof(short?), Expression.Constant(null));
+			Assert.Null(Utils.GetDataReaderValue(typeof(short?), null));
+			var exp2222 = Utils.GetDataReaderValueBlockExpression(typeof(short?), Expression.Constant("aaa"));
+			Assert.Null(Utils.GetDataReaderValue(typeof(short?), "aaa"));
+		}
+
+		[Fact]
+		public void Int() {
+			var exp1 = Utils.GetDataReaderValueBlockExpression(typeof(int), Expression.Constant(int.MinValue));
+			Assert.Equal(int.MinValue, Utils.GetDataReaderValue(typeof(int), int.MinValue));
+			var exp2 = Utils.GetDataReaderValueBlockExpression(typeof(int), Expression.Constant(int.MaxValue));
+			Assert.Equal(int.MaxValue, Utils.GetDataReaderValue(typeof(int), int.MaxValue));
+			var exp3 = Utils.GetDataReaderValueBlockExpression(typeof(int), Expression.Constant("127"));
+			Assert.Equal((int)127, Utils.GetDataReaderValue(typeof(int), "127"));
+
+			var exp11 = Utils.GetDataReaderValueBlockExpression(typeof(int?), Expression.Constant(int.MinValue));
+			Assert.Equal(int.MinValue, Utils.GetDataReaderValue(typeof(int?), int.MinValue));
+			var exp22 = Utils.GetDataReaderValueBlockExpression(typeof(int?), Expression.Constant(int.MaxValue));
+			Assert.Equal(int.MaxValue, Utils.GetDataReaderValue(typeof(int?), int.MaxValue));
+			var exp33 = Utils.GetDataReaderValueBlockExpression(typeof(int?), Expression.Constant("127"));
+			Assert.Equal((int)127, Utils.GetDataReaderValue(typeof(int?), "127"));
+
+			var exp111 = Utils.GetDataReaderValueBlockExpression(typeof(int), Expression.Constant(null));
+			Assert.Equal(default(int), Utils.GetDataReaderValue(typeof(int), null));
+			var exp222 = Utils.GetDataReaderValueBlockExpression(typeof(int), Expression.Constant("aaa"));
+			Assert.Equal(default(int), Utils.GetDataReaderValue(typeof(int), "aaa"));
+
+			var exp1111 = Utils.GetDataReaderValueBlockExpression(typeof(int?), Expression.Constant(null));
+			Assert.Null(Utils.GetDataReaderValue(typeof(int?), null));
+			var exp2222 = Utils.GetDataReaderValueBlockExpression(typeof(int?), Expression.Constant("aaa"));
+			Assert.Null(Utils.GetDataReaderValue(typeof(int?), "aaa"));
+		}
+
+		[Fact]
+		public void Long() {
+			var exp1 = Utils.GetDataReaderValueBlockExpression(typeof(long), Expression.Constant(long.MinValue));
+			Assert.Equal(long.MinValue, Utils.GetDataReaderValue(typeof(long), long.MinValue));
+			var exp2 = Utils.GetDataReaderValueBlockExpression(typeof(long), Expression.Constant(long.MaxValue));
+			Assert.Equal(long.MaxValue, Utils.GetDataReaderValue(typeof(long), long.MaxValue));
+			var exp3 = Utils.GetDataReaderValueBlockExpression(typeof(long), Expression.Constant("127"));
+			Assert.Equal((long)127, Utils.GetDataReaderValue(typeof(long), "127"));
+
+			var exp11 = Utils.GetDataReaderValueBlockExpression(typeof(long?), Expression.Constant(long.MinValue));
+			Assert.Equal(long.MinValue, Utils.GetDataReaderValue(typeof(long?), long.MinValue));
+			var exp22 = Utils.GetDataReaderValueBlockExpression(typeof(long?), Expression.Constant(long.MaxValue));
+			Assert.Equal(long.MaxValue, Utils.GetDataReaderValue(typeof(long?), long.MaxValue));
+			var exp33 = Utils.GetDataReaderValueBlockExpression(typeof(long?), Expression.Constant("127"));
+			Assert.Equal((long)127, Utils.GetDataReaderValue(typeof(long?), "127"));
+
+			var exp111 = Utils.GetDataReaderValueBlockExpression(typeof(long), Expression.Constant(null));
+			Assert.Equal(default(long), Utils.GetDataReaderValue(typeof(long), null));
+			var exp222 = Utils.GetDataReaderValueBlockExpression(typeof(long), Expression.Constant("aaa"));
+			Assert.Equal(default(long), Utils.GetDataReaderValue(typeof(long), "aaa"));
+
+			var exp1111 = Utils.GetDataReaderValueBlockExpression(typeof(long?), Expression.Constant(null));
+			Assert.Null(Utils.GetDataReaderValue(typeof(long?), null));
+			var exp2222 = Utils.GetDataReaderValueBlockExpression(typeof(long?), Expression.Constant("aaa"));
+			Assert.Null(Utils.GetDataReaderValue(typeof(long?), "aaa"));
+		}
+
+		[Fact]
+		public void Byte() {
+			var exp1 = Utils.GetDataReaderValueBlockExpression(typeof(byte), Expression.Constant(byte.MinValue));
+			Assert.Equal(byte.MinValue, Utils.GetDataReaderValue(typeof(byte), byte.MinValue));
+			var exp2 = Utils.GetDataReaderValueBlockExpression(typeof(byte), Expression.Constant(byte.MaxValue));
+			Assert.Equal(byte.MaxValue, Utils.GetDataReaderValue(typeof(byte), byte.MaxValue));
+			var exp3 = Utils.GetDataReaderValueBlockExpression(typeof(byte), Expression.Constant("127"));
+			Assert.Equal((byte)127, Utils.GetDataReaderValue(typeof(byte), "127"));
+
+			var exp11 = Utils.GetDataReaderValueBlockExpression(typeof(byte?), Expression.Constant(byte.MinValue));
+			Assert.Equal(byte.MinValue, Utils.GetDataReaderValue(typeof(byte?), byte.MinValue));
+			var exp22 = Utils.GetDataReaderValueBlockExpression(typeof(byte?), Expression.Constant(byte.MaxValue));
+			Assert.Equal(byte.MaxValue, Utils.GetDataReaderValue(typeof(byte?), byte.MaxValue));
+			var exp33 = Utils.GetDataReaderValueBlockExpression(typeof(byte?), Expression.Constant("127"));
+			Assert.Equal((byte)127, Utils.GetDataReaderValue(typeof(byte?), "127"));
+
+			var exp111 = Utils.GetDataReaderValueBlockExpression(typeof(byte), Expression.Constant(null));
+			Assert.Equal(default(byte), Utils.GetDataReaderValue(typeof(byte), null));
+			var exp222 = Utils.GetDataReaderValueBlockExpression(typeof(byte), Expression.Constant("aaa"));
+			Assert.Equal(default(byte), Utils.GetDataReaderValue(typeof(byte), "aaa"));
+
+			var exp1111 = Utils.GetDataReaderValueBlockExpression(typeof(byte?), Expression.Constant(null));
+			Assert.Null(Utils.GetDataReaderValue(typeof(byte?), null));
+			var exp2222 = Utils.GetDataReaderValueBlockExpression(typeof(byte?), Expression.Constant("aaa"));
+			Assert.Null(Utils.GetDataReaderValue(typeof(byte?), "aaa"));
+		}
+
+		[Fact]
+		public void UShort() {
+			var exp1 = Utils.GetDataReaderValueBlockExpression(typeof(ushort), Expression.Constant(ushort.MinValue));
+			Assert.Equal(ushort.MinValue, Utils.GetDataReaderValue(typeof(ushort), ushort.MinValue));
+			var exp2 = Utils.GetDataReaderValueBlockExpression(typeof(ushort), Expression.Constant(ushort.MaxValue));
+			Assert.Equal(ushort.MaxValue, Utils.GetDataReaderValue(typeof(ushort), ushort.MaxValue));
+			var exp3 = Utils.GetDataReaderValueBlockExpression(typeof(ushort), Expression.Constant("127"));
+			Assert.Equal((ushort)127, Utils.GetDataReaderValue(typeof(ushort), "127"));
+
+			var exp11 = Utils.GetDataReaderValueBlockExpression(typeof(ushort?), Expression.Constant(ushort.MinValue));
+			Assert.Equal(ushort.MinValue, Utils.GetDataReaderValue(typeof(ushort?), ushort.MinValue));
+			var exp22 = Utils.GetDataReaderValueBlockExpression(typeof(ushort?), Expression.Constant(ushort.MaxValue));
+			Assert.Equal(ushort.MaxValue, Utils.GetDataReaderValue(typeof(ushort?), ushort.MaxValue));
+			var exp33 = Utils.GetDataReaderValueBlockExpression(typeof(ushort?), Expression.Constant("127"));
+			Assert.Equal((ushort)127, Utils.GetDataReaderValue(typeof(ushort?), "127"));
+
+			var exp111 = Utils.GetDataReaderValueBlockExpression(typeof(ushort), Expression.Constant(null));
+			Assert.Equal(default(ushort), Utils.GetDataReaderValue(typeof(ushort), null));
+			var exp222 = Utils.GetDataReaderValueBlockExpression(typeof(ushort), Expression.Constant("aaa"));
+			Assert.Equal(default(ushort), Utils.GetDataReaderValue(typeof(ushort), "aaa"));
+
+			var exp1111 = Utils.GetDataReaderValueBlockExpression(typeof(ushort?), Expression.Constant(null));
+			Assert.Null(Utils.GetDataReaderValue(typeof(ushort?), null));
+			var exp2222 = Utils.GetDataReaderValueBlockExpression(typeof(ushort?), Expression.Constant("aaa"));
+			Assert.Null(Utils.GetDataReaderValue(typeof(ushort?), "aaa"));
+		}
+
+		[Fact]
+		public void UInt() {
+			var exp1 = Utils.GetDataReaderValueBlockExpression(typeof(uint), Expression.Constant(uint.MinValue));
+			Assert.Equal(uint.MinValue, Utils.GetDataReaderValue(typeof(uint), uint.MinValue));
+			var exp2 = Utils.GetDataReaderValueBlockExpression(typeof(uint), Expression.Constant(uint.MaxValue));
+			Assert.Equal(uint.MaxValue, Utils.GetDataReaderValue(typeof(uint), uint.MaxValue));
+			var exp3 = Utils.GetDataReaderValueBlockExpression(typeof(uint), Expression.Constant("127"));
+			Assert.Equal((uint)127, Utils.GetDataReaderValue(typeof(uint), "127"));
+
+			var exp11 = Utils.GetDataReaderValueBlockExpression(typeof(uint?), Expression.Constant(uint.MinValue));
+			Assert.Equal(uint.MinValue, Utils.GetDataReaderValue(typeof(uint?), uint.MinValue));
+			var exp22 = Utils.GetDataReaderValueBlockExpression(typeof(uint?), Expression.Constant(uint.MaxValue));
+			Assert.Equal(uint.MaxValue, Utils.GetDataReaderValue(typeof(uint?), uint.MaxValue));
+			var exp33 = Utils.GetDataReaderValueBlockExpression(typeof(uint?), Expression.Constant("127"));
+			Assert.Equal((uint)127, Utils.GetDataReaderValue(typeof(uint?), "127"));
+
+			var exp111 = Utils.GetDataReaderValueBlockExpression(typeof(uint), Expression.Constant(null));
+			Assert.Equal(default(uint), Utils.GetDataReaderValue(typeof(uint), null));
+			var exp222 = Utils.GetDataReaderValueBlockExpression(typeof(uint), Expression.Constant("aaa"));
+			Assert.Equal(default(uint), Utils.GetDataReaderValue(typeof(uint), "aaa"));
+
+			var exp1111 = Utils.GetDataReaderValueBlockExpression(typeof(uint?), Expression.Constant(null));
+			Assert.Null(Utils.GetDataReaderValue(typeof(uint?), null));
+			var exp2222 = Utils.GetDataReaderValueBlockExpression(typeof(uint?), Expression.Constant("aaa"));
+			Assert.Null(Utils.GetDataReaderValue(typeof(uint?), "aaa"));
+		}
+
+		[Fact]
+		public void ULong() {
+			var exp1 = Utils.GetDataReaderValueBlockExpression(typeof(ulong), Expression.Constant(ulong.MinValue));
+			Assert.Equal(ulong.MinValue, Utils.GetDataReaderValue(typeof(ulong), ulong.MinValue));
+			var exp2 = Utils.GetDataReaderValueBlockExpression(typeof(ulong), Expression.Constant(ulong.MaxValue));
+			Assert.Equal(ulong.MaxValue, Utils.GetDataReaderValue(typeof(ulong), ulong.MaxValue));
+			var exp3 = Utils.GetDataReaderValueBlockExpression(typeof(ulong), Expression.Constant("127"));
+			Assert.Equal((ulong)127, Utils.GetDataReaderValue(typeof(ulong), "127"));
+
+			var exp11 = Utils.GetDataReaderValueBlockExpression(typeof(ulong?), Expression.Constant(ulong.MinValue));
+			Assert.Equal(ulong.MinValue, Utils.GetDataReaderValue(typeof(ulong?), ulong.MinValue));
+			var exp22 = Utils.GetDataReaderValueBlockExpression(typeof(ulong?), Expression.Constant(ulong.MaxValue));
+			Assert.Equal(ulong.MaxValue, Utils.GetDataReaderValue(typeof(ulong?), ulong.MaxValue));
+			var exp33 = Utils.GetDataReaderValueBlockExpression(typeof(ulong?), Expression.Constant("127"));
+			Assert.Equal((ulong)127, Utils.GetDataReaderValue(typeof(ulong?), "127"));
+
+			var exp111 = Utils.GetDataReaderValueBlockExpression(typeof(ulong), Expression.Constant(null));
+			Assert.Equal(default(ulong), Utils.GetDataReaderValue(typeof(ulong), null));
+			var exp222 = Utils.GetDataReaderValueBlockExpression(typeof(ulong), Expression.Constant("aaa"));
+			Assert.Equal(default(ulong), Utils.GetDataReaderValue(typeof(ulong), "aaa"));
+
+			var exp1111 = Utils.GetDataReaderValueBlockExpression(typeof(ulong?), Expression.Constant(null));
+			Assert.Null(Utils.GetDataReaderValue(typeof(ulong?), null));
+			var exp2222 = Utils.GetDataReaderValueBlockExpression(typeof(ulong?), Expression.Constant("aaa"));
+			Assert.Null(Utils.GetDataReaderValue(typeof(ulong?), "aaa"));
+		}
+
+		[Fact]
+		public void Float() {
+			var exp1 = Utils.GetDataReaderValueBlockExpression(typeof(float), Expression.Constant(float.MinValue));
+			Assert.Equal(float.MinValue, Utils.GetDataReaderValue(typeof(float), float.MinValue));
+			var exp2 = Utils.GetDataReaderValueBlockExpression(typeof(float), Expression.Constant(float.MaxValue));
+			Assert.Equal(float.MaxValue, Utils.GetDataReaderValue(typeof(float), float.MaxValue));
+			var exp3 = Utils.GetDataReaderValueBlockExpression(typeof(float), Expression.Constant("127"));
+			Assert.Equal((float)127, Utils.GetDataReaderValue(typeof(float), "127"));
+
+			var exp11 = Utils.GetDataReaderValueBlockExpression(typeof(float?), Expression.Constant(float.MinValue));
+			Assert.Equal(float.MinValue, Utils.GetDataReaderValue(typeof(float?), float.MinValue));
+			var exp22 = Utils.GetDataReaderValueBlockExpression(typeof(float?), Expression.Constant(float.MaxValue));
+			Assert.Equal(float.MaxValue, Utils.GetDataReaderValue(typeof(float?), float.MaxValue));
+			var exp33 = Utils.GetDataReaderValueBlockExpression(typeof(float?), Expression.Constant("127"));
+			Assert.Equal((float)127, Utils.GetDataReaderValue(typeof(float?), "127"));
+
+			var exp111 = Utils.GetDataReaderValueBlockExpression(typeof(float), Expression.Constant(null));
+			Assert.Equal(default(float), Utils.GetDataReaderValue(typeof(float), null));
+			var exp222 = Utils.GetDataReaderValueBlockExpression(typeof(float), Expression.Constant("aaa"));
+			Assert.Equal(default(float), Utils.GetDataReaderValue(typeof(float), "aaa"));
+
+			var exp1111 = Utils.GetDataReaderValueBlockExpression(typeof(float?), Expression.Constant(null));
+			Assert.Null(Utils.GetDataReaderValue(typeof(float?), null));
+			var exp2222 = Utils.GetDataReaderValueBlockExpression(typeof(float?), Expression.Constant("aaa"));
+			Assert.Null(Utils.GetDataReaderValue(typeof(float?), "aaa"));
+		}
+
+		[Fact]
+		public void Double() {
+			var exp1 = Utils.GetDataReaderValueBlockExpression(typeof(double), Expression.Constant(double.MinValue));
+			Assert.Equal(double.MinValue, Utils.GetDataReaderValue(typeof(double), double.MinValue));
+			var exp2 = Utils.GetDataReaderValueBlockExpression(typeof(double), Expression.Constant(double.MaxValue));
+			Assert.Equal(double.MaxValue, Utils.GetDataReaderValue(typeof(double), double.MaxValue));
+			var exp3 = Utils.GetDataReaderValueBlockExpression(typeof(double), Expression.Constant("127"));
+			Assert.Equal((double)127, Utils.GetDataReaderValue(typeof(double), "127"));
+
+			var exp11 = Utils.GetDataReaderValueBlockExpression(typeof(double?), Expression.Constant(double.MinValue));
+			Assert.Equal(double.MinValue, Utils.GetDataReaderValue(typeof(double?), double.MinValue));
+			var exp22 = Utils.GetDataReaderValueBlockExpression(typeof(double?), Expression.Constant(double.MaxValue));
+			Assert.Equal(double.MaxValue, Utils.GetDataReaderValue(typeof(double?), double.MaxValue));
+			var exp33 = Utils.GetDataReaderValueBlockExpression(typeof(double?), Expression.Constant("127"));
+			Assert.Equal((double)127, Utils.GetDataReaderValue(typeof(double?), "127"));
+
+			var exp111 = Utils.GetDataReaderValueBlockExpression(typeof(double), Expression.Constant(null));
+			Assert.Equal(default(double), Utils.GetDataReaderValue(typeof(double), null));
+			var exp222 = Utils.GetDataReaderValueBlockExpression(typeof(double), Expression.Constant("aaa"));
+			Assert.Equal(default(double), Utils.GetDataReaderValue(typeof(double), "aaa"));
+
+			var exp1111 = Utils.GetDataReaderValueBlockExpression(typeof(double?), Expression.Constant(null));
+			Assert.Null(Utils.GetDataReaderValue(typeof(double?), null));
+			var exp2222 = Utils.GetDataReaderValueBlockExpression(typeof(double?), Expression.Constant("aaa"));
+			Assert.Null(Utils.GetDataReaderValue(typeof(double?), "aaa"));
+		}
+
+		[Fact]
+		public void Decimal() {
+			var exp1 = Utils.GetDataReaderValueBlockExpression(typeof(decimal), Expression.Constant(decimal.MinValue));
+			Assert.Equal(decimal.MinValue, Utils.GetDataReaderValue(typeof(decimal), decimal.MinValue));
+			var exp2 = Utils.GetDataReaderValueBlockExpression(typeof(decimal), Expression.Constant(decimal.MaxValue));
+			Assert.Equal(decimal.MaxValue, Utils.GetDataReaderValue(typeof(decimal), decimal.MaxValue));
+			var exp3 = Utils.GetDataReaderValueBlockExpression(typeof(decimal), Expression.Constant("127"));
+			Assert.Equal((decimal)127, Utils.GetDataReaderValue(typeof(decimal), "127"));
+
+			var exp11 = Utils.GetDataReaderValueBlockExpression(typeof(decimal?), Expression.Constant(decimal.MinValue));
+			Assert.Equal(decimal.MinValue, Utils.GetDataReaderValue(typeof(decimal?), decimal.MinValue));
+			var exp22 = Utils.GetDataReaderValueBlockExpression(typeof(decimal?), Expression.Constant(decimal.MaxValue));
+			Assert.Equal(decimal.MaxValue, Utils.GetDataReaderValue(typeof(decimal?), decimal.MaxValue));
+			var exp33 = Utils.GetDataReaderValueBlockExpression(typeof(decimal?), Expression.Constant("127"));
+			Assert.Equal((decimal)127, Utils.GetDataReaderValue(typeof(decimal?), "127"));
+
+			var exp111 = Utils.GetDataReaderValueBlockExpression(typeof(decimal), Expression.Constant(null));
+			Assert.Equal(default(decimal), Utils.GetDataReaderValue(typeof(decimal), null));
+			var exp222 = Utils.GetDataReaderValueBlockExpression(typeof(decimal), Expression.Constant("aaa"));
+			Assert.Equal(default(decimal), Utils.GetDataReaderValue(typeof(decimal), "aaa"));
+
+			var exp1111 = Utils.GetDataReaderValueBlockExpression(typeof(decimal?), Expression.Constant(null));
+			Assert.Null(Utils.GetDataReaderValue(typeof(decimal?), null));
+			var exp2222 = Utils.GetDataReaderValueBlockExpression(typeof(decimal?), Expression.Constant("aaa"));
+			Assert.Null(Utils.GetDataReaderValue(typeof(decimal?), "aaa"));
+		}
+	}
+}

FreeSql.Tests/MySql/Curd/MySqlSelectTest.cs

@@ -139,7 +139,8 @@ namespace FreeSql.Tests.MySql {
 
 		class TestDto {
 			public int id { get; set; }
-			public string name { get; set; }
+			public string name { get; set; } //这是join表的属性
+			public int ParentId { get; set; } //这是join表的属性
 		}
 		[Fact]
 		public void ToList() {
@@ -149,6 +150,10 @@ namespace FreeSql.Tests.MySql {
 			var testDto3 = select.Limit(10).ToList(a => new TestDto { });
 			var testDto4 = select.Limit(10).ToList(a => new TestDto() { });
 
+			var testDto11 = select.LeftJoin(a => a.Type.Guid == a.TypeGuid).Limit(10).ToList(a => new TestDto { id = a.Id, name = a.Title });
+			var testDto22 = select.LeftJoin(a => a.Type.Guid == a.TypeGuid).Limit(10).ToList(a => new TestDto());
+			var testDto33 = select.LeftJoin(a => a.Type.Guid == a.TypeGuid).Limit(10).ToList(a => new TestDto { });
+			var testDto44 = select.LeftJoin(a => a.Type.Guid == a.TypeGuid).Limit(10).ToList(a => new TestDto() { });
 
 			var t0 = select.Limit(50).ToList();
 
@@ -303,14 +308,20 @@ namespace FreeSql.Tests.MySql {
 		}
 		[Fact]
 		public void From() {
-			//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+			var query2 = select.From<TestTypeInfo>((s, b) => s
-			var query2 = select.From<TestTypeInfo, TestTypeParentInfo>((s, b, c) => s
+				 .LeftJoin(a => a.TypeGuid == b.Guid)
+				);
+			var sql2 = query2.ToSql().Replace("\r\n", "");
+			Assert.Equal("SELECT a.`Id`, a.`Clicks`, a.`TypeGuid`, b.`Guid`, b.`ParentId`, b.`Name`, a.`Title`, a.`CreateTime` FROM `tb_topic` a LEFT JOIN `TestTypeInfo` b ON a.`TypeGuid` = b.`Guid`", sql2);
+			query2.ToList();
+
+			var query3 = select.From<TestTypeInfo, TestTypeParentInfo>((s, b, c) => s
 				 .LeftJoin(a => a.TypeGuid == b.Guid)
 				 .LeftJoin(a => b.ParentId == c.Id)
 				);
-			var sql = query2.ToSql().Replace("\r\n", "");
+			var sql3 = query3.ToSql().Replace("\r\n", "");
-			Assert.Equal("SELECT a.`Id`, a.`Clicks`, a.`TypeGuid`, b.`Guid`, b.`ParentId`, b.`Name`, a.`Title`, a.`CreateTime` FROM `tb_topic` a LEFT JOIN `TestTypeInfo` b ON a.`TypeGuid` = b.`Guid` LEFT JOIN `TestTypeParentInfo` c ON b.`ParentId` = c.`Id`", sql);
+			Assert.Equal("SELECT a.`Id`, a.`Clicks`, a.`TypeGuid`, b.`Guid`, b.`ParentId`, b.`Name`, a.`Title`, a.`CreateTime` FROM `tb_topic` a LEFT JOIN `TestTypeInfo` b ON a.`TypeGuid` = b.`Guid` LEFT JOIN `TestTypeParentInfo` c ON b.`ParentId` = c.`Id`", sql3);
-			query2.ToList();
+			query3.ToList();
 		}
 		[Fact]
 		public void LeftJoin() {

FreeSql.Tests/Oracle/Curd/OracleSelectTest.cs

@@ -130,7 +130,8 @@ namespace FreeSql.Tests.Oracle {
 		}
 		class TestDto {
 			public int id { get; set; }
-			public string name { get; set; }
+			public string name { get; set; } //这是join表的属性
+			public int ParentId { get; set; } //这是join表的属性
 		}
 		[Fact]
 		public void ToList() {
@@ -140,6 +141,11 @@ namespace FreeSql.Tests.Oracle {
 			var testDto3 = select.Limit(10).ToList(a => new TestDto { });
 			var testDto4 = select.Limit(10).ToList(a => new TestDto() { });
 
+			var testDto11 = select.LeftJoin(a => a.Type.Guid == a.TypeGuid).Limit(10).ToList(a => new TestDto { id = a.Id, name = a.Title });
+			var testDto22 = select.LeftJoin(a => a.Type.Guid == a.TypeGuid).Limit(10).ToList(a => new TestDto());
+			var testDto33 = select.LeftJoin(a => a.Type.Guid == a.TypeGuid).Limit(10).ToList(a => new TestDto { });
+			var testDto44 = select.LeftJoin(a => a.Type.Guid == a.TypeGuid).Limit(10).ToList(a => new TestDto() { });
+
 			g.oracle.Insert<TestGuidIdToList>().AppendData(new TestGuidIdToList()).ExecuteAffrows();
 			var testGuidId5 = g.oracle.Select<TestGuidIdToList>().ToList();
 			var testGuidId6 = g.oracle.Select<TestGuidIdToList>().ToList(a => a.id);
@@ -199,14 +205,20 @@ namespace FreeSql.Tests.Oracle {
 		}
 		[Fact]
 		public void From() {
-			//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+			var query2 = select.From<TestTypeInfo>((s, b) => s
-			var query2 = select.From<TestTypeInfo, TestTypeParentInfo>((s, b, c) => s
+				 .LeftJoin(a => a.TypeGuid == b.Guid)
+				);
+			var sql2 = query2.ToSql().Replace("\r\n", "");
+			Assert.Equal("SELECT a.\"ID\", a.\"CLICKS\", a.\"TYPEGUID\", b.\"GUID\", b.\"PARENTID\", b.\"NAME\", a.\"TITLE\", a.\"CREATETIME\" FROM \"TB_TOPIC22\" a LEFT JOIN \"TESTTYPEINFO\" b ON a.\"TYPEGUID\" = b.\"GUID\"", sql2);
+			query2.ToList();
+
+			var query3 = select.From<TestTypeInfo, TestTypeParentInfo>((s, b, c) => s
 				 .LeftJoin(a => a.TypeGuid == b.Guid)
 				 .LeftJoin(a => b.ParentId == c.Id)
 				);
-			var sql = query2.ToSql().Replace("\r\n", "");
+			var sql3 = query3.ToSql().Replace("\r\n", "");
-			Assert.Equal("SELECT a.\"ID\", a.\"CLICKS\", a.\"TYPEGUID\", b.\"GUID\", b.\"PARENTID\", b.\"NAME\", a.\"TITLE\", a.\"CREATETIME\" FROM \"TB_TOPIC22\" a LEFT JOIN \"TESTTYPEINFO\" b ON a.\"TYPEGUID\" = b.\"GUID\" LEFT JOIN \"TESTTYPEPARENTINFO\" c ON b.\"PARENTID\" = c.\"ID\"", sql);
+			Assert.Equal("SELECT a.\"ID\", a.\"CLICKS\", a.\"TYPEGUID\", b.\"GUID\", b.\"PARENTID\", b.\"NAME\", a.\"TITLE\", a.\"CREATETIME\" FROM \"TB_TOPIC22\" a LEFT JOIN \"TESTTYPEINFO\" b ON a.\"TYPEGUID\" = b.\"GUID\" LEFT JOIN \"TESTTYPEPARENTINFO\" c ON b.\"PARENTID\" = c.\"ID\"", sql3);
-			query2.ToList();
+			query3.ToList();
 		}
 		[Fact]
 		public void LeftJoin() {

FreeSql.Tests/PostgreSQL/Curd/PostgreSQLSelectTest.cs

@@ -121,7 +121,8 @@ namespace FreeSql.Tests.PostgreSQL {
 		}
 		class TestDto {
 			public int id { get; set; }
-			public string name { get; set; }
+			public string name { get; set; } //这是join表的属性
+			public int ParentId { get; set; } //这是join表的属性
 		}
 		[Fact]
 		public void ToList() {
@@ -131,6 +132,11 @@ namespace FreeSql.Tests.PostgreSQL {
 			var testDto3 = select.Limit(10).ToList(a => new TestDto { });
 			var testDto4 = select.Limit(10).ToList(a => new TestDto() { });
 
+			var testDto11 = select.LeftJoin(a => a.Type.Guid == a.TypeGuid).Limit(10).ToList(a => new TestDto { id = a.Id, name = a.Title });
+			var testDto22 = select.LeftJoin(a => a.Type.Guid == a.TypeGuid).Limit(10).ToList(a => new TestDto());
+			var testDto33 = select.LeftJoin(a => a.Type.Guid == a.TypeGuid).Limit(10).ToList(a => new TestDto { });
+			var testDto44 = select.LeftJoin(a => a.Type.Guid == a.TypeGuid).Limit(10).ToList(a => new TestDto() { });
+
 
 			var t1 = g.pgsql.Select<TestInfo>().Where("").Where(a => a.Id > 0).Skip(100).Limit(200).ToSql();
 			var t2 = g.pgsql.Select<TestInfo>().As("b").Where("").Where(a => a.Id > 0).Skip(100).Limit(200).ToSql();
@@ -269,14 +275,21 @@ namespace FreeSql.Tests.PostgreSQL {
 		}
 		[Fact]
 		public void From() {
-			//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+
-			var query2 = select.From<TestTypeInfo, TestTypeParentInfo>((s, b, c) => s
+			var query2 = select.From<TestTypeInfo>((s, b) => s
+				 .LeftJoin(a => a.TypeGuid == b.Guid)
+				);
+			var sql2 = query2.ToSql().Replace("\r\n", "");
+			Assert.Equal("SELECT a.\"id\", a.\"clicks\", a.\"typeguid\", b.\"guid\", b.\"parentid\", b.\"name\", a.\"title\", a.\"createtime\" FROM \"tb_topic\" a LEFT JOIN \"testtypeinfo\" b ON a.\"typeguid\" = b.\"guid\"", sql2);
+			query2.ToList();
+
+			var query3 = select.From<TestTypeInfo, TestTypeParentInfo>((s, b, c) => s
 				 .LeftJoin(a => a.TypeGuid == b.Guid)
 				 .LeftJoin(a => b.ParentId == c.Id)
 				);
-			var sql = query2.ToSql().Replace("\r\n", "");
+			var sql3 = query3.ToSql().Replace("\r\n", "");
-			Assert.Equal("SELECT a.\"id\", a.\"clicks\", a.\"typeguid\", b.\"guid\", b.\"parentid\", b.\"name\", a.\"title\", a.\"createtime\" FROM \"tb_topic\" a LEFT JOIN \"testtypeinfo\" b ON a.\"typeguid\" = b.\"guid\" LEFT JOIN \"testtypeparentinfo\" c ON b.\"parentid\" = c.\"id\"", sql);
+			Assert.Equal("SELECT a.\"id\", a.\"clicks\", a.\"typeguid\", b.\"guid\", b.\"parentid\", b.\"name\", a.\"title\", a.\"createtime\" FROM \"tb_topic\" a LEFT JOIN \"testtypeinfo\" b ON a.\"typeguid\" = b.\"guid\" LEFT JOIN \"testtypeparentinfo\" c ON b.\"parentid\" = c.\"id\"", sql3);
-			query2.ToList();
+			query3.ToList();
 		}
 		[Fact]
 		public void LeftJoin() {

FreeSql.Tests/SqlServer/Curd/SqlServerSelectTest.cs

@@ -132,7 +132,8 @@ namespace FreeSql.Tests.SqlServer {
 		}
 		class TestDto {
 			public int id { get; set; }
-			public string name { get; set; }
+			public string name { get; set; } //这是join表的属性
+			public int ParentId { get; set; } //这是join表的属性
 		}
 		[Fact]
 		public void ToList() {
@@ -142,6 +143,11 @@ namespace FreeSql.Tests.SqlServer {
 			var testDto3 = select.Limit(10).ToList(a => new TestDto { });
 			var testDto4 = select.Limit(10).ToList(a => new TestDto() { });
 
+			var testDto11 = select.LeftJoin(a => a.Type.Guid == a.TypeGuid).Limit(10).ToList(a => new TestDto { id = a.Id, name = a.Title });
+			var testDto22 = select.LeftJoin(a => a.Type.Guid == a.TypeGuid).Limit(10).ToList(a => new TestDto());
+			var testDto33 = select.LeftJoin(a => a.Type.Guid == a.TypeGuid).Limit(10).ToList(a => new TestDto { });
+			var testDto44 = select.LeftJoin(a => a.Type.Guid == a.TypeGuid).Limit(10).ToList(a => new TestDto() { });
+
 			_sqlserverFixture.SqlServer.Insert<TestGuidIdToList>().AppendData(new TestGuidIdToList()).ExecuteAffrows();
 			var testGuidId5 = _sqlserverFixture.SqlServer.Select<TestGuidIdToList>().ToList();
 			var testGuidId6 = _sqlserverFixture.SqlServer.Select<TestGuidIdToList>().ToList(a => a.id);
@@ -201,14 +207,20 @@ namespace FreeSql.Tests.SqlServer {
 		}
 		[Fact]
 		public void From() {
-			//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+			var query2 = select.From<TestTypeInfo>((s, b) => s
-			var query2 = select.From<TestTypeInfo, TestTypeParentInfo>((s, b, c) => s
+				 .LeftJoin(a => a.TypeGuid == b.Guid)
+				);
+			var sql2 = query2.ToSql().Replace("\r\n", "");
+			Assert.Equal("SELECT a.[Id], a.[Clicks], a.[TypeGuid], b.[Guid], b.[ParentId], b.[Name], a.[Title], a.[CreateTime] FROM [tb_topic22] a LEFT JOIN [TestTypeInfo] b ON a.[TypeGuid] = b.[Guid]", sql2);
+			query2.ToList();
+
+			var query3 = select.From<TestTypeInfo, TestTypeParentInfo>((s, b, c) => s
 				 .LeftJoin(a => a.TypeGuid == b.Guid)
 				 .LeftJoin(a => b.ParentId == c.Id)
 				);
-			var sql = query2.ToSql().Replace("\r\n", "");
+			var sql3 = query3.ToSql().Replace("\r\n", "");
-			Assert.Equal("SELECT a.[Id], a.[Clicks], a.[TypeGuid], b.[Guid], b.[ParentId], b.[Name], a.[Title], a.[CreateTime] FROM [tb_topic22] a LEFT JOIN [TestTypeInfo] b ON a.[TypeGuid] = b.[Guid] LEFT JOIN [TestTypeParentInfo] c ON b.[ParentId] = c.[Id]", sql);
+			Assert.Equal("SELECT a.[Id], a.[Clicks], a.[TypeGuid], b.[Guid], b.[ParentId], b.[Name], a.[Title], a.[CreateTime] FROM [tb_topic22] a LEFT JOIN [TestTypeInfo] b ON a.[TypeGuid] = b.[Guid] LEFT JOIN [TestTypeParentInfo] c ON b.[ParentId] = c.[Id]", sql3);
-			query2.ToList();
+			query3.ToList();
 		}
 		[Fact]
 		public void LeftJoin() {

FreeSql.Tests/Sqlite/Curd/SqliteSelectTest.cs

@@ -124,7 +124,8 @@ namespace FreeSql.Tests.Sqlite {
 		}
 		class TestDto {
 			public int id { get; set; }
-			public string name { get; set; }
+			public string name { get; set; } //这是join表的属性
+			public int ParentId { get; set; } //这是join表的属性
 		}
 		[Fact]
 		public void ToList() {
@@ -134,6 +135,11 @@ namespace FreeSql.Tests.Sqlite {
 			var testDto3 = select.Limit(10).ToList(a => new TestDto { });
 			var testDto4 = select.Limit(10).ToList(a => new TestDto() { });
 
+			var testDto11 = select.LeftJoin(a => a.Type.Guid == a.TypeGuid).Limit(10).ToList(a => new TestDto { id = a.Id, name = a.Title });
+			var testDto22 = select.LeftJoin(a => a.Type.Guid == a.TypeGuid).Limit(10).ToList(a => new TestDto());
+			var testDto33 = select.LeftJoin(a => a.Type.Guid == a.TypeGuid).Limit(10).ToList(a => new TestDto { });
+			var testDto44 = select.LeftJoin(a => a.Type.Guid == a.TypeGuid).Limit(10).ToList(a => new TestDto() { });
+
 			g.sqlite.Insert<TestGuidIdToList>().AppendData(new TestGuidIdToList()).ExecuteAffrows();
 			var testGuidId5 = g.sqlite.Select<TestGuidIdToList>().ToList();
 			var testGuidId6 = g.sqlite.Select<TestGuidIdToList>().ToList(a => a.id);
@@ -193,14 +199,20 @@ namespace FreeSql.Tests.Sqlite {
 		}
 		[Fact]
 		public void From() {
-			//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+			var query2 = select.From<TestTypeInfo>((s, b) => s
-			var query2 = select.From<TestTypeInfo, TestTypeParentInfo>((s, b, c) => s
+				 .LeftJoin(a => a.TypeGuid == b.Guid)
+				);
+			var sql2 = query2.ToSql().Replace("\r\n", "");
+			Assert.Equal("SELECT a.\"Id\", a.\"Clicks\", a.\"TypeGuid\", b.\"Guid\", b.\"ParentId\", b.\"Name\", a.\"Title\", a.\"CreateTime\" FROM \"tb_topic22\" a LEFT JOIN \"TestTypeInfo\" b ON a.\"TypeGuid\" = b.\"Guid\"", sql2);
+			query2.ToList();
+
+			var query3 = select.From<TestTypeInfo, TestTypeParentInfo>((s, b, c) => s
 				 .LeftJoin(a => a.TypeGuid == b.Guid)
 				 .LeftJoin(a => b.ParentId == c.Id)
 				);
-			var sql = query2.ToSql().Replace("\r\n", "");
+			var sql3 = query3.ToSql().Replace("\r\n", "");
-			Assert.Equal("SELECT a.\"Id\", a.\"Clicks\", a.\"TypeGuid\", b.\"Guid\", b.\"ParentId\", b.\"Name\", a.\"Title\", a.\"CreateTime\" FROM \"tb_topic22\" a LEFT JOIN \"TestTypeInfo\" b ON a.\"TypeGuid\" = b.\"Guid\" LEFT JOIN \"TestTypeParentInfo\" c ON b.\"ParentId\" = c.\"Id\"", sql);
+			Assert.Equal("SELECT a.\"Id\", a.\"Clicks\", a.\"TypeGuid\", b.\"Guid\", b.\"ParentId\", b.\"Name\", a.\"Title\", a.\"CreateTime\" FROM \"tb_topic22\" a LEFT JOIN \"TestTypeInfo\" b ON a.\"TypeGuid\" = b.\"Guid\" LEFT JOIN \"TestTypeParentInfo\" c ON b.\"ParentId\" = c.\"Id\"", sql3);
-			query2.ToList();
+			query3.ToList();
 		}
 		[Fact]
 		public void LeftJoin() {

FreeSql.Tests/UnitTest1.cs

@@ -74,7 +74,7 @@ namespace FreeSql.Tests {
 			//var dic = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, dynamic>>(testjson);
 			var reqs = Newtonsoft.Json.JsonConvert.DeserializeObject<List<ServiceRequestNew>>(testjson);
 			reqs.ForEach(t => {
-					g.oracle.Insert(t).ExecuteAffrows();
+				g.oracle.Insert<ServiceRequestNew>(t).ExecuteAffrows();
 				
 			});
 

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 = "*|_,[,_|*") {
+		public static void GetEntityKeyString<TEntity>(this IFreeSql orm, TEntity entity, string splitString = "*|_,[,_|*") =>
-			var func = _dicGetEntityKeyString.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Func<object, string>>()).GetOrAdd(typeof(TEntity), t => {
+			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) {
+		public static void GetEntityKeyValues<TEntity>(this IFreeSql orm, TEntity entity) =>
-			var func = _dicGetEntityKeyValues.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Func<object, object[]>>()).GetOrAdd(typeof(TEntity), t => {
+			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) {
+		public static void GetEntityString<TEntity>(this IFreeSql orm, TEntity entity) =>
-			var func = _dicGetEntityString.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Func<object, string>>()).GetOrAdd(typeof(TEntity), t => {
+			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) {
+		public static void MapEntityValue<TEntity>(this IFreeSql orm, TEntity entityFrom, TEntity entityTo) =>
-			var func = _dicMapEntityValue.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Action<object, object>>()).GetOrAdd(typeof(TEntity), t => {
+			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) {
+		public static void MapEntityKeyValue<TEntity>(this IFreeSql orm, TEntity entityFrom, TEntity entityTo) =>
-			var func = _dicMapEntityKeyValue.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Action<object, object>>()).GetOrAdd(typeof(TEntity), t => {
+			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) {
+		public static void SetEntityIdentityValueWithPrimary<TEntity>(this IFreeSql orm, TEntity entity, long idtval) =>
-			var func = _dicSetEntityIdentityValueWithPrimary.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Action<object, long>>()).GetOrAdd(typeof(TEntity), t => {
+			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>
+		/// <param name="entity"></param>
-		public static long GetEntityIdentityValueWithPrimary<TEntity>(this IFreeSql orm, TEntity item) {
+		public static void GetEntityIdentityValueWithPrimary<TEntity>(this IFreeSql orm, TEntity entity) =>
-			var func = _dicGetEntityIdentityValueWithPrimary.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Func<object, long>>()).GetOrAdd(typeof(TEntity), t => {
+			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>
+		/// <param name="entity"></param>
-		public static void ClearEntityPrimaryValueWithIdentityAndGuid<TEntity>(this IFreeSql orm, TEntity item) {
+		public static void ClearEntityPrimaryValueWithIdentityAndGuid<TEntity>(this IFreeSql orm, TEntity entity) =>
-			var func = _dicClearEntityPrimaryValueWithIdentityAndGuid.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Action<object>>()).GetOrAdd(typeof(TEntity), t => {
+			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>
+		/// <param name="entity"></param>
-		public static void ClearEntityPrimaryValueWithIdentity<TEntity>(this IFreeSql orm, TEntity item) {
+		public static void ClearEntityPrimaryValueWithIdentity<TEntity>(this IFreeSql orm, TEntity entity) =>
-			var func = _dicClearEntityPrimaryValueWithIdentity.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Action<object>>()).GetOrAdd(typeof(TEntity), t => {
+			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="entity1"></param>
-		/// <param name="oldval"></param>
+		/// <param name="entity2"></param>
 		/// <returns></returns>
-		public static string[] CompareEntityValueReturnColumns<TEntity>(this IFreeSql orm, TEntity up, TEntity oldval, bool isEqual) {
+		public static void CompareEntityValueReturnColumns<TEntity>(this IFreeSql orm, TEntity entity1, TEntity entity2, bool isEqual) =>
-			var func = _dicCompareEntityValueReturnColumns.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Func<object, object, bool, string[]>>()).GetOrAdd(typeof(TEntity), t => {
+			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="entity"></param>
-		/// <param name="idtval"></param>
+		/// <param name="propertyName"></param>
-		public static void SetEntityIncrByWithPropertyName<TEntity>(this IFreeSql orm, TEntity item, string propertyName, int incrBy) {
+		/// <param name="value"></param>
-			var func = _dicSetEntityIncrByWithPropertyName.GetOrAdd(orm.Ado.DataType, dt => new ConcurrentDictionary<Type, Action<object, string, int>>()).GetOrAdd(typeof(TEntity), t => {
+		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[]>();

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>

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>

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>

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);
+	}
+}

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)) {
+							foreach (var dtTb in _tables) {
-								var child = new ReadAnonymousTypeInfo {
+								if (dtTb.Table.Columns.TryGetValue(dtoProp.Name, out var trydtocol)) {
-									Property = dtoProp,
+									var child = new ReadAnonymousTypeInfo {
-									CsName = dtoProp.Name,
+										Property = dtoProp,
-									CsType = dtoProp.PropertyType
+										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);
+									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)) {
+							foreach(var dtTb in _tables) {
-								var child = new ReadAnonymousTypeInfo {
+								if (dtTb.Table.ColumnsByCs.TryGetValue(dtoProp.Name, out var trydtocol)) {
-									Property = dtoProp,
+									var child = new ReadAnonymousTypeInfo {
-									CsName = dtoProp.Name,
+										Property = dtoProp,
-									CsType = dtoProp.PropertyType
+										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);
+									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;
 			}

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);

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; }

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();
+		}
+	}
+}

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");
@@ -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) {
+				Expression tryparseExp = null;
-					case "System.Guid": return Expression.IfThenElse(
+				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();

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);

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);

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 {
+	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 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);
+		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);

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 {
+	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 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);
+		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);

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);