Update Core

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/AdoProvider/AdoProvider.cs

@@ -409,9 +409,9 @@ namespace SqlSugar
                 var sqlCommand = GetCommand(sql, parameters);
                 int count;
                 if (this.CancellationToken == null)
-                    count = await sqlCommand.ExecuteNonQueryAsync();
+                    count=await sqlCommand.ExecuteNonQueryAsync();
                 else
-                    count = await sqlCommand.ExecuteNonQueryAsync(this.CancellationToken.Value);
+                    count=await sqlCommand.ExecuteNonQueryAsync(this.CancellationToken.Value);
                 if (this.IsClearParameters)
                     sqlCommand.Parameters.Clear();
                 ExecuteAfter(sql, parameters);
@@ -446,10 +446,10 @@ namespace SqlSugar
                 ExecuteBefore(sql, parameters);
                 var sqlCommand = GetCommand(sql, parameters);
                 DbDataReader sqlDataReader;
-                if (this.CancellationToken == null)
+                if(this.CancellationToken==null)
-                    sqlDataReader = await sqlCommand.ExecuteReaderAsync(this.IsAutoClose() ? CommandBehavior.CloseConnection : CommandBehavior.Default);
+                    sqlDataReader=await sqlCommand.ExecuteReaderAsync(this.IsAutoClose() ? CommandBehavior.CloseConnection : CommandBehavior.Default);
                 else
-                    sqlDataReader = await sqlCommand.ExecuteReaderAsync(this.IsAutoClose() ? CommandBehavior.CloseConnection : CommandBehavior.Default, this.CancellationToken.Value);
+                    sqlDataReader=await sqlCommand.ExecuteReaderAsync(this.IsAutoClose() ? CommandBehavior.CloseConnection : CommandBehavior.Default,this.CancellationToken.Value);
                 if (isSp)
                     DataReaderParameters = sqlCommand.Parameters;
                 if (this.IsClearParameters)
@@ -482,8 +482,8 @@ namespace SqlSugar
                 ExecuteBefore(sql, parameters);
                 var sqlCommand = GetCommand(sql, parameters);
                 object scalar;
-                if (CancellationToken == null)
+                if(CancellationToken==null)
-                    scalar = await sqlCommand.ExecuteScalarAsync();
+                    scalar=await sqlCommand.ExecuteScalarAsync();
                 else
                     scalar = await sqlCommand.ExecuteScalarAsync(this.CancellationToken.Value);
                 //scalar = (scalar == null ? 0 : scalar);
@@ -898,7 +898,7 @@ namespace SqlSugar
         }
         public async Task<Tuple<List<T>, List<T2>, List<T3>, List<T4>, List<T5>, List<T6>>> SqlQueryAsync<T, T2, T3, T4, T5, T6>(string sql, object parameters = null)
         {
-            var result = await SqlQueryAsync<T, T2, T3, T4, T5, T6, object>(sql, parameters);
+            var result =await SqlQueryAsync<T, T2, T3, T4, T5, T6, object>(sql, parameters);
             return new Tuple<List<T>, List<T2>, List<T3>, List<T4>, List<T5>, List<T6>>(result.Item1, result.Item2, result.Item3, result.Item4, result.Item5, result.Item6);
         }
         public async Task<Tuple<List<T>, List<T2>, List<T3>, List<T4>, List<T5>, List<T6>, List<T7>>> SqlQueryAsync<T, T2, T3, T4, T5, T6, T7>(string sql, object parameters = null)
@@ -915,7 +915,7 @@ namespace SqlSugar
                 List<T> result = new List<T>();
                 if (DbReader.HasRows)
                 {
-                    result = await GetDataAsync<T>(typeof(T), dataReader);
+                    result =await GetDataAsync<T>(typeof(T), dataReader);
                 }
                 List<T2> result2 = null;
                 if (NextResult(dataReader))
@@ -1196,7 +1196,7 @@ namespace SqlSugar
             {
                 return dataReader.NextResult();
             }
-            catch
+            catch  
             {
                 return false;
             }
@@ -1361,7 +1361,7 @@ namespace SqlSugar
                     if (item.Value != null)
                     {
                         var type = item.Value.GetType();
-                        if ((type != UtilConstants.ByteArrayType && type.IsArray && item.IsArray == false) || type.FullName.IsCollectionsList())
+                        if ((type != UtilConstants.ByteArrayType && type.IsArray&&item.IsArray==false) || type.FullName.IsCollectionsList())
                         {
                             var newValues = new List<string>();
                             foreach (var inValute in item.Value as IEnumerable)
@@ -1378,7 +1378,7 @@ namespace SqlSugar
                             }
                             if (item.ParameterName.Substring(0, 1) != this.SqlParameterKeyWord)
                             {
-                                sql = sql.Replace(this.SqlParameterKeyWord + item.ParameterName, newValues.ToArray().ToJoinSqlInVals());
+                                sql = sql.Replace(this.SqlParameterKeyWord+item.ParameterName, newValues.ToArray().ToJoinSqlInVals());
                             }
                             else
                             {
@@ -1416,7 +1416,7 @@ namespace SqlSugar
             List<TResult> result;
             if (entityType == UtilConstants.DynamicType)
             {
-                result = await this.Context.Utilities.DataReaderToExpandoObjectListAsyncNoUsing(dataReader) as List<TResult>;
+                result =await this.Context.Utilities.DataReaderToExpandoObjectListAsyncNoUsing(dataReader) as List<TResult>;
             }
             else if (entityType == UtilConstants.ObjType)
             {
@@ -1425,11 +1425,11 @@ namespace SqlSugar
             }
             else if (entityType.IsAnonymousType())
             {
-                result = await this.Context.Utilities.DataReaderToListAsyncNoUsing<TResult>(dataReader);
+                result =await this.Context.Utilities.DataReaderToListAsyncNoUsing<TResult>(dataReader);
             }
             else
             {
-                result = await this.Context.Ado.DbBind.DataReaderToListNoUsingAsync<TResult>(entityType, dataReader);
+                result =await this.Context.Ado.DbBind.DataReaderToListNoUsingAsync<TResult>(entityType, dataReader);
             }
             return result;
         }

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DbBindProvider/IDataReaderEntityBuilder.cs

@@ -332,6 +332,8 @@ namespace SqlSugar
                     if (bindProperyTypeName == "datetime")
                         method = isNullableType ? getConvertdatetimeoffsetDate : getdatetimeoffsetDate;
                     break;
+                case CSharpDataType.Single:
+                    break;
                 default:
                     method = getConvertValueMethod.MakeGenericMethod(bindPropertyType);
                     break;

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DbFirstProvider/DbFirstProvider.cs

@@ -101,7 +101,7 @@ namespace SqlSugar
             if (this.Context.CurrentConnectionConfig.ConfigureExternalServices?.RazorService != null)
             {
                 List<RazorTableInfo> razorList = new List<RazorTableInfo>();
-                var tables = this.Context.DbMaintenance.GetTableInfoList(false);
+                var tables = this.TableInfoList;
                 if (tables.HasValue())
                 {
                     foreach (var item in tables)

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DbMaintenanceProvider/Methods.cs

@@ -308,6 +308,12 @@ namespace SqlSugar
             this.Context.Ado.ExecuteCommand(sql);
             return true;
         }
+        public virtual bool CreateUniqueIndex(string tableName, string[] columnNames)
+        {
+            string sql = string.Format(CreateIndexSql, tableName, string.Join(",", columnNames), string.Join("_", columnNames)+"_Unique","UNIQUE" );
+            this.Context.Ado.ExecuteCommand(sql);
+            return true;
+        }
         public virtual bool IsAnyIndex(string indexName)
         {
             string sql = string.Format(this.IsAnyIndexSql, indexName);
@@ -369,6 +375,22 @@ namespace SqlSugar
                     }
                 }
             }
+
+
+            var uIndexColumns = columns.Where(it => it.UIndexGroupNameList.HasValue()).ToList();
+            if (uIndexColumns.HasValue())
+            {
+                var groups = uIndexColumns.SelectMany(it => it.UIndexGroupNameList).GroupBy(it => it).Select(it => it.Key).ToList();
+                foreach (var item in groups)
+                {
+                    var columnNames = uIndexColumns.Where(it => it.UIndexGroupNameList.Any(i => i.Equals(item, StringComparison.CurrentCultureIgnoreCase))).Select(it => it.DbColumnName).ToArray();
+                    var indexName = string.Format("Index_{0}_{1}_Unique", entityInfo.DbTableName, string.Join("_", columnNames));
+                    if (!IsAnyIndex(indexName))
+                    {
+                        CreateUniqueIndex(entityInfo.DbTableName, columnNames);
+                    }
+                }
+            }
         }
 
         protected virtual bool IsAnyDefaultValue(string tableName, string columnName,List<DbColumnInfo> columns)

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/EntityMaintenance/EntityMaintenance.cs

@@ -193,7 +193,7 @@ namespace SqlSugar
                         column.NoSerialize = sugarColumn.NoSerialize;
                         column.DefaultValue = sugarColumn.DefaultValue;
                         column.IndexGroupNameList = sugarColumn.IndexGroupNameList;
-                        column.UIndexGroupNameList = sugarColumn.UIndexGroupNameList;
+                        column.UIndexGroupNameList = sugarColumn.UniqueGroupNameList;
                         column.IsOnlyIgnoreUpdate = sugarColumn.IsOnlyIgnoreUpdate;
                         column.IsArray = sugarColumn.IsArray;
                     }

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/InsertableProvider/InsertableProvider.cs

@@ -640,7 +640,7 @@ namespace SqlSugar
                         DiffLogColumnInfo addItem = new DiffLogColumnInfo();
                         addItem.Value = row[col.ColumnName];
                         addItem.ColumnName = col.ColumnName;
-                        addItem.ColumnDescription = this.EntityInfo.Columns.First(it => it.DbColumnName.Equals(col.ColumnName, StringComparison.CurrentCultureIgnoreCase)).ColumnDescription;
+                        addItem.ColumnDescription = this.EntityInfo.Columns.Where(it=>it.DbColumnName!=null).First(it => it.DbColumnName.Equals(col.ColumnName, StringComparison.CurrentCultureIgnoreCase)).ColumnDescription;
                         item.Columns.Add(addItem);
                     }
                     result.Add(item);

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/QueryableProvider/QueryableProvider.cs

@@ -783,6 +783,38 @@ namespace SqlSugar
             return result;
         }
 
+        public Dictionary<string, object> ToDictionary(Expression<Func<T, object>> key, Expression<Func<T, object>> value)
+        {
+            var keyName = QueryBuilder.GetExpressionValue(key, ResolveExpressType.FieldSingle).GetResultString();
+            var valueName = QueryBuilder.GetExpressionValue(value, ResolveExpressType.FieldSingle).GetResultString();
+            var result = this.Select<KeyValuePair<string, object>>(keyName + "," + valueName).ToList().ToDictionary(it => it.Key.ObjToString(), it => it.Value);
+            return result;
+        }
+        public async Task<Dictionary<string, object>> ToDictionaryAsync(Expression<Func<T, object>> key, Expression<Func<T, object>> value)
+        {
+            var keyName = QueryBuilder.GetExpressionValue(key, ResolveExpressType.FieldSingle);
+            var valueName = QueryBuilder.GetExpressionValue(value, ResolveExpressType.FieldSingle);
+            var list = await this.Select<KeyValuePair<string, object>>(keyName + "," + valueName).ToListAsync();
+            var result =list.ToDictionary(it => it.Key.ObjToString(), it => it.Value);
+            return result;
+        }
+        public List<Dictionary<string, object>> ToDictionaryList()
+        {
+            var list = this.ToList();
+            if (list == null)
+                return null;
+            else
+                return this.Context.Utilities.DeserializeObject<List<Dictionary<string, object>>>(this.Context.Utilities.SerializeObject(list));
+        }
+        public async Task<List<Dictionary<string, object>>> ToDictionaryListAsync()
+        {
+            var list =await this.ToListAsync();
+            if (list == null)
+                return null;
+            else
+                return this.Context.Utilities.DeserializeObject<List<Dictionary<string, object>>>(this.Context.Utilities.SerializeObject(list));
+        }
+
         public virtual List<T> ToList()
         {
             InitMapping();
@@ -1958,7 +1990,27 @@ namespace SqlSugar
         protected void CopyQueryBuilder(QueryBuilder asyncQueryableBuilder)
         {
             var pars = new List<SugarParameter>();
-            pars.AddRange(this.QueryBuilder.Parameters);
+            if (this.QueryBuilder.Parameters != null)
+            {
+                pars=this.QueryBuilder.Parameters.Select(it=>new SugarParameter(it.ParameterName,it.Value) {
+                       DbType=it.DbType,
+                       Value=it.Value,
+                       ParameterName=it.ParameterName,
+                       Direction=it.Direction,
+                       IsArray=it.IsArray,
+                       IsJson=it.IsJson,
+                       IsNullable=it.IsNullable,
+                       IsRefCursor=it.IsRefCursor,
+                       Size=it.Size,
+                       SourceColumn=it.SourceColumn,
+                       SourceColumnNullMapping=it.SourceColumnNullMapping,
+                       SourceVersion=it.SourceVersion,
+                       TempDate=it.TempDate,
+                       TypeName=it.TypeName,
+                       UdtTypeName=it.UdtTypeName,
+                       _Size=it._Size
+                }).ToList();
+            }
             asyncQueryableBuilder.Take = this.QueryBuilder.Take;
             asyncQueryableBuilder.Skip = this.QueryBuilder.Skip;
             asyncQueryableBuilder.SelectValue = this.QueryBuilder.SelectValue;

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/InsertBuilder.cs

@@ -5,7 +5,7 @@ using System.Linq;
 using System.Linq.Expressions;
 namespace SqlSugar
 {
-    public class InsertBuilder : IDMLBuilder
+    public partial class InsertBuilder : IDMLBuilder
     {
         #region  Init
         public InsertBuilder()

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/SqlBuilderProvider.cs

@@ -183,7 +183,7 @@ namespace SqlSugar
                             break;
                         case ConditionalType.NoLike:
                             builder.AppendFormat(temp, type, item.FieldName.ToSqlFilter(), " NOT LIKE", parameterName);
-                            parameters.Add(new SugarParameter(parameterName, item.FieldValue + "%"));
+                            parameters.Add(new SugarParameter(parameterName, "%" + item.FieldValue + "%"));
                             break;
                         case ConditionalType.LikeRight:
                             builder.AppendFormat(temp, type, item.FieldName.ToSqlFilter(), "LIKE", parameterName);

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SugarProvider/SqlSugarProvider.cs

@@ -444,6 +444,61 @@ namespace SqlSugar
 
             return queryable;
         }
+
+
+        public virtual ISugarQueryable<T, T2 ,T3> Queryable<T, T2 ,T3>(
+                ISugarQueryable<T> joinQueryable1, ISugarQueryable<T2> joinQueryable2, ISugarQueryable<T3> joinQueryable3,
+                JoinType joinType1, Expression<Func<T, T2, T3, bool>> joinExpression1 ,
+                JoinType joinType2 , Expression<Func<T, T2, T3,bool>> joinExpression2
+            ) where T : class, new() where T2 : class, new() where T3 : class, new()
+        {
+            Check.Exception(joinQueryable1.QueryBuilder.Take != null || joinQueryable1.QueryBuilder.Skip != null || joinQueryable1.QueryBuilder.OrderByValue.HasValue(), "joinQueryable1 Cannot have 'Skip' 'ToPageList' 'Take' Or 'OrderBy'");
+            Check.Exception(joinQueryable2.QueryBuilder.Take != null || joinQueryable2.QueryBuilder.Skip != null || joinQueryable2.QueryBuilder.OrderByValue.HasValue(), "joinQueryable2 Cannot have 'Skip' 'ToPageList' 'Take' Or 'OrderBy'");
+            Check.Exception(joinQueryable3.QueryBuilder.Take != null || joinQueryable3.QueryBuilder.Skip != null || joinQueryable3.QueryBuilder.OrderByValue.HasValue(), "joinQueryable3 Cannot have 'Skip' 'ToPageList' 'Take' Or 'OrderBy'");
+
+            var sqlBuilder = InstanceFactory.GetSqlbuilder(this.Context.CurrentConnectionConfig);
+
+            sqlBuilder.Context = this;
+            InitMappingInfo<T, T2,T3>();
+            var types = new Type[] { typeof(T2) };
+            var queryable = InstanceFactory.GetQueryable<T, T2,T3>(this.CurrentConnectionConfig);
+            queryable.Context = this.Context;
+            queryable.SqlBuilder = sqlBuilder;
+            queryable.QueryBuilder = InstanceFactory.GetQueryBuilder(this.CurrentConnectionConfig);
+            queryable.QueryBuilder.JoinQueryInfos = new List<JoinQueryInfo>();
+            queryable.QueryBuilder.Builder = sqlBuilder;
+            queryable.QueryBuilder.Context = this;
+            queryable.QueryBuilder.EntityType = typeof(T);
+            queryable.QueryBuilder.LambdaExpressions = InstanceFactory.GetLambdaExpressions(this.CurrentConnectionConfig);
+
+            //master
+            var shortName1 = joinExpression1.Parameters[0].Name;
+            var sqlObj1 = joinQueryable1.ToSql();
+            string sql1 = sqlObj1.Key;
+            UtilMethods.RepairReplicationParameters(ref sql1, sqlObj1.Value.ToArray(), 0, "Join");
+            queryable.QueryBuilder.EntityName = sqlBuilder.GetPackTable(sql1, shortName1); ;
+            queryable.QueryBuilder.Parameters.AddRange(sqlObj1.Value);
+
+            //join table 1
+            var shortName2 = joinExpression1.Parameters[1].Name;
+            var sqlObj2 = joinQueryable2.ToSql();
+            string sql2 = sqlObj2.Key;
+            UtilMethods.RepairReplicationParameters(ref sql2, sqlObj2.Value.ToArray(), 1, "Join");
+            queryable.QueryBuilder.Parameters.AddRange(sqlObj2.Value);
+            var exp = queryable.QueryBuilder.GetExpressionValue(joinExpression1, ResolveExpressType.WhereMultiple);
+            queryable.QueryBuilder.JoinQueryInfos.Add(new JoinQueryInfo() { JoinIndex = 0, JoinType = joinType1, JoinWhere = exp.GetResultString(), TableName = sqlBuilder.GetPackTable(sql2, shortName2) });
+
+
+            //join table 2
+            var shortName3 = joinExpression1.Parameters[2].Name;
+            var sqlObj3 = joinQueryable3.ToSql();
+            string sql3 = sqlObj3.Key;
+            UtilMethods.RepairReplicationParameters(ref sql3, sqlObj3.Value.ToArray(), 2, "Join");
+            queryable.QueryBuilder.Parameters.AddRange(sqlObj3.Value);
+            var exp2 = queryable.QueryBuilder.GetExpressionValue(joinExpression2, ResolveExpressType.WhereMultiple);
+            queryable.QueryBuilder.JoinQueryInfos.Add(new JoinQueryInfo() { JoinIndex = 1, JoinType = joinType2, JoinWhere = exp2.GetResultString(), TableName = sqlBuilder.GetPackTable(sql3, shortName3) });
+            return queryable;
+        }
         #endregion
 
         public virtual ISugarQueryable<T> UnionAll<T>(params ISugarQueryable<T>[] queryables) where T : class, new()

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/UpdateProvider/UpdateableProvider.cs

@@ -745,7 +745,7 @@ namespace SqlSugar
                         DiffLogColumnInfo addItem = new DiffLogColumnInfo();
                         addItem.Value = row[col.ColumnName];
                         addItem.ColumnName = col.ColumnName;
-                        addItem.ColumnDescription = this.EntityInfo.Columns.First(it => it.DbColumnName.Equals(col.ColumnName, StringComparison.CurrentCultureIgnoreCase)).ColumnDescription;
+                        addItem.ColumnDescription = this.EntityInfo.Columns.Where(it=>it.DbColumnName!=null).First(it => it.DbColumnName.Equals(col.ColumnName, StringComparison.CurrentCultureIgnoreCase)).ColumnDescription;
                         item.Columns.Add(addItem);
                     }
                     result.Add(item);

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Entities/Mapping/SugarMappingAttribute.cs

@@ -171,7 +171,7 @@ namespace SqlSugar
             set { _IndexGroupNameList = value; }
         }
 
-        public string[] UIndexGroupNameList { get; set; }
+        public string[] UniqueGroupNameList { get; set; }
 
         private bool _IsArray;
         public bool IsArray

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve.cs

@@ -512,6 +512,10 @@ namespace SqlSugar
                 {
                     name = "To" + TempParseType.Name;
                 }
+                else if (name == "IsNullOrWhiteSpace")
+                {
+                    name = "IsNullOrEmpty";
+                }
                 switch (name)
                 {
                     case "IIF":
@@ -696,6 +700,10 @@ namespace SqlSugar
             {
                 return true;
             }
+            if (expression.Method.Name == "IsNullOrWhiteSpace" && expression.Method.DeclaringType == UtilConstants.StringType)
+            {
+                return true;
+            }
             if (expression.Method.ReflectedType().FullName != ExpressionConst.SqlFuncFullName)
                 return false;
             else

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Infrastructure/ContextMethods.cs

@@ -286,6 +286,10 @@ namespace SqlSugar
                     {
                         result.Add(name, DeserializeObject<List<Dictionary<string, object>>>(readerValues[item.Name.ToLower()].ToString()));
                     }
+                    else if (IsBytes(readerValues, item))
+                    {
+                        result.Add(name,(byte[])readerValues[item.Name.ToLower()]);
+                    }
                     else
                     {
                         result.Add(name, DataReaderToDynamicList_Part(readerValues, item, reval));
@@ -335,6 +339,14 @@ namespace SqlSugar
             return result;
         }
 
+        private static bool IsBytes(Dictionary<string, object> readerValues, PropertyInfo item)
+        {
+            return item.PropertyType == UtilConstants.ByteArrayType && 
+                   readerValues.ContainsKey(item.Name.ToLower())&&
+                   (readerValues[item.Name.ToLower()]==null||
+                   readerValues[item.Name.ToLower()].GetType()==UtilConstants.ByteArrayType);
+        }
+
         private static bool IsJsonItem(Dictionary<string, object> readerValues, string name)
         {
             return readerValues != null &&

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IQueryable.cs

@@ -122,6 +122,12 @@ namespace SqlSugar
         Task<TResult> AvgAsync<TResult>(Expression<Func<T, TResult>> expression);
 
         List<T> ToList();
+
+        Dictionary<string, object> ToDictionary(Expression<Func<T, object>> key, Expression<Func<T, object>> value);
+        Task<Dictionary<string, object>> ToDictionaryAsync(Expression<Func<T, object>> key, Expression<Func<T, object>> value);
+        List<Dictionary<string, object>> ToDictionaryList();
+        Task<List<Dictionary<string, object>>> ToDictionaryListAsync();
+
         T[] ToArray();
         Task<List<T>> ToListAsync();
 

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/ISqlSugarClient.cs

@@ -102,6 +102,14 @@ namespace SqlSugar
         ISugarQueryable<T, T2> Queryable<T, T2>(ISugarQueryable<T> joinQueryable1, ISugarQueryable<T2> joinQueryable2, JoinType joinType, Expression<Func<T, T2, bool>> joinExpression)
             where T : class, new()
             where T2 : class, new();
+
+        ISugarQueryable<T, T2, T3> Queryable<T, T2, T3>(ISugarQueryable<T> joinQueryable1, ISugarQueryable<T2> joinQueryable2, ISugarQueryable<T3> joinQueryable3,
+          JoinType joinType1, Expression<Func<T, T2,T3, bool>> joinExpression1,
+          JoinType joinType2, Expression<Func<T, T2,T3, bool>> joinExpression2)
+           where T: class, new() 
+           where T2 : class, new() 
+           where T3 : class, new();
+
         ISugarQueryable<T> Queryable<T>();
         ISugarQueryable<T> Queryable<T>(ISugarQueryable<T> queryable) where T : class, new();
         ISugarQueryable<T> Queryable<T>(string shortName);

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/Insertable.cs

@@ -7,7 +7,7 @@ using System.Threading.Tasks;
 
 namespace SqlSugar
 {
-    public interface IInsertable<T>
+    public partial interface IInsertable<T>
     {
         InsertBuilder InsertBuilder { get; set; }
         int ExecuteCommand();

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Dm/DbBind/DmDbBind.cs

@@ -102,6 +102,9 @@ namespace SqlSugar
                   new KeyValuePair<string, CSharpDataType>("varchar",CSharpDataType.@Guid),
                   new KeyValuePair<string, CSharpDataType>("varchar2",CSharpDataType.@string),
                   new KeyValuePair<string, CSharpDataType>("nvarchar2",CSharpDataType.@string),
+                  new KeyValuePair<string, CSharpDataType>("longvarchar",CSharpDataType.@string),
+                  
+
                   new KeyValuePair<string, CSharpDataType>("char",CSharpDataType.@string),
                   new KeyValuePair<string, CSharpDataType>("nchar",CSharpDataType.@string),
                   new KeyValuePair<string, CSharpDataType>("clob",CSharpDataType.@string),

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarClient.cs

@@ -307,6 +307,18 @@ namespace SqlSugar
             return this.Context.Queryable(joinQueryable1, joinQueryable2, joinType, joinExpression);
         }
 
+
+        public ISugarQueryable<T, T2, T3> Queryable<T, T2,T3>(ISugarQueryable<T> joinQueryable1, ISugarQueryable<T2> joinQueryable2, ISugarQueryable<T3> joinQueryable3,
+            JoinType joinType1, Expression<Func<T, T2,T3, bool>> joinExpression1,
+            JoinType joinType2, Expression<Func<T, T2,T3, bool>> joinExpression2)
+      where T : class, new()
+      where T2 : class, new()
+      where T3 : class, new()
+        {
+            return this.Context.Queryable(joinQueryable1, joinQueryable2,joinQueryable3, joinType1, joinExpression1,joinType2,joinExpression2);
+        }
+
+
         public ISugarQueryable<T> Queryable<T>()
         {
             return this.Context.Queryable<T>();