-

OrmTest/Demo/Query.cs

@@ -63,6 +63,7 @@ namespace OrmTest.Demo
             var sum = db.Queryable<Student>().Sum(it=>it.Id);
             var isAny = db.Queryable<Student>().Where(it=>it.Id==-1).Any();
             var isAny2 = db.Queryable<Student>().Any(it => it.Id == -1);
+            var getListByRename = db.Queryable<School>().AS("Student").ToList();
         }
 
         public static void Page()

OrmTest/Demo/Update.cs

@@ -51,8 +51,7 @@ namespace OrmTest.Demo
                 .Where(it => it.Id == 11).ExecuteCommand();
 
             //Rename 
-            db.MappingTables.Add("School", "Student");
+            db.Updateable<School>().AS("Student").UpdateColumns(it => new School() { Name = "jack" }).Where(it => it.Id == 1).ExecuteCommand();
-            db.Updateable<School>().UpdateColumns(it => new School() { Name = "jack" }).Where(it => it.Id == 1).ExecuteCommand();
             //Update Student set Name='jack' Where Id=1
         }
         public static SqlSugarClient GetInstance()

SqlSugar/Abstract/DbMaintenanceProvider/DbMaintenanceProvider.cs

@@ -28,6 +28,7 @@ namespace SqlSugar
         }
         public virtual List<DbColumnInfo> GetColumnInfosByTableName(string tableName)
         {
+            if (string.IsNullOrEmpty(tableName)) return new List<DbColumnInfo>();
             string key = "DbMaintenanceProvider.GetColumnInfosByTableName." + tableName.ToLower();
             return GetListOrCache<DbColumnInfo>(key, this.GetColumnInfosByTableNameSql);
         }

SqlSugar/Abstract/DeleteProvider/DeleteableProvider.cs

@@ -13,6 +13,8 @@ namespace SqlSugar
         public IAdo Db { get { return Context.Ado; } }
         public ISqlBuilder SqlBuilder { get; set; }
         public DeleteBuilder DeleteBuilder { get; set; }
+        public MappingTableList OldMappingTableList { get; set; }
+        public bool IsAs { get; set; }
         public EntityInfo EntityInfo
         {
             get
@@ -25,8 +27,17 @@ namespace SqlSugar
             DeleteBuilder.EntityInfo = this.Context.EntityProvider.GetEntityInfo<T>();
             string sql = DeleteBuilder.ToSqlString();
             var paramters = DeleteBuilder.Parameters==null?null:DeleteBuilder.Parameters.ToArray();
+            RestoreMapping();
             return Db.GetInt(sql, paramters);
         }
+        public IDeleteable<T> AS(string tableName)
+        {
+            var entityName = typeof(T).Name;
+            IsAs = true;
+            this.Context.MappingTables = this.Context.RewritableMethods.TranslateCopy(this.Context.MappingTables);
+            this.Context.MappingTables.Add(entityName, tableName);
+            return this; ;
+        }
 
         public IDeleteable<T> Where(List<T> deleteObjs)
         {
@@ -149,6 +160,7 @@ namespace SqlSugar
             DeleteBuilder.EntityInfo = this.Context.EntityProvider.GetEntityInfo<T>();
             string sql = DeleteBuilder.ToSqlString();
             var paramters = DeleteBuilder.Parameters == null ? null : DeleteBuilder.Parameters.ToList();
+            RestoreMapping();
             return new KeyValuePair<string, List<SugarParameter>>(sql, paramters);
         }
 
@@ -175,5 +187,12 @@ namespace SqlSugar
                 return this.EntityInfo.Columns.Where(it => it.IsIdentity).Select(it => it.DbColumnName).ToList();
             }
         }
+        private void RestoreMapping()
+        {
+            if (IsAs)
+            {
+                this.Context.MappingTables = OldMappingTableList;
+            }
+        }
     }
 }

SqlSugar/Abstract/InsertableProvider/InsertableProvider.cs

@@ -24,29 +24,46 @@ namespace SqlSugar
         private bool IsOffIdentity { get; set; }
         public T[] InsertObjs { get; set; }
 
+        public MappingTableList OldMappingTableList { get; set; }
+        public bool IsAs { get; set; }
+
         #region Core
         public int ExecuteCommand()
         {
             InsertBuilder.IsReturnIdentity = false;
             PreToSql();
-            return Ado.ExecuteCommand(InsertBuilder.ToSqlString(), InsertBuilder.Parameters.ToArray());
+            string sql = InsertBuilder.ToSqlString();
+            RestoreMapping();
+            return Ado.ExecuteCommand(sql, InsertBuilder.Parameters.ToArray());
         }
+
         public KeyValuePair<string, List<SugarParameter>> ToSql()
         {
             InsertBuilder.IsReturnIdentity = true;
             PreToSql();
             string sql = InsertBuilder.ToSqlString();
+            RestoreMapping();
             return new KeyValuePair<string, List<SugarParameter>>(sql, InsertBuilder.Parameters);
         }
         public int ExecuteReutrnIdentity()
         {
             InsertBuilder.IsReturnIdentity = true;
             PreToSql();
-            return Ado.GetInt(InsertBuilder.ToSqlString(), InsertBuilder.Parameters.ToArray());
+            string sql = InsertBuilder.ToSqlString();
+            RestoreMapping();
+            return Ado.GetInt(sql, InsertBuilder.Parameters.ToArray());
         }
         #endregion
 
         #region Setting
+        public IInsertable<T> AS(string tableName)
+        {
+            var entityName = typeof(T).Name;
+            IsAs = true;
+            this.Context.MappingTables = this.Context.RewritableMethods.TranslateCopy(this.Context.MappingTables);
+            this.Context.MappingTables.Add(entityName, tableName);
+            return this; ;
+        }
         public IInsertable<T> IgnoreColumns(Expression<Func<T, object>> columns)
         {
             var ignoreColumns = InsertBuilder.GetExpressionValue(columns, ResolveExpressType.Array).GetResultArray();
@@ -188,6 +205,13 @@ namespace SqlSugar
                 return this.EntityInfo.Columns.Where(it => it.IsIdentity).Select(it => it.DbColumnName).ToList();
             }
         }
+        private void RestoreMapping()
+        {
+            if (IsAs)
+            {
+                this.Context.MappingTables = OldMappingTableList;
+            }
+        }
         #endregion
     }
 }

SqlSugar/Abstract/QueryableProvider/QueryableProvider.cs

@@ -16,6 +16,8 @@ namespace SqlSugar
         public IAdo Db { get { return Context.Ado; } }
         public IDbBind Bind { get { return this.Db.DbBind; } }
         public ISqlBuilder SqlBuilder { get; set; }
+        public MappingTableList OldMappingTableList { get; set; }
+        public bool IsAs { get; set; }
         public QueryBuilder QueryBuilder
         {
             get
@@ -34,7 +36,22 @@ namespace SqlSugar
         {
             QueryBuilder.Clear();
         }
-
+        public ISugarQueryable<T> AS<T2>(string tableName)
+        {
+            var entityName = typeof(T2).Name;
+            IsAs = true;
+            this.Context.MappingTables = this.Context.RewritableMethods.TranslateCopy(this.Context.MappingTables);
+            this.Context.MappingTables.Add(entityName, tableName);
+            return this;
+        }
+        public ISugarQueryable<T> AS(string tableName)
+        {
+            var entityName = typeof(T).Name;
+            IsAs = true;
+            this.Context.MappingTables = this.Context.RewritableMethods.TranslateCopy(this.Context.MappingTables);
+            this.Context.MappingTables.Add(entityName, tableName);
+            return this;
+        }
         public ISugarQueryable<T> AddParameters(object whereObj)
         {
             if (whereObj != null)
@@ -395,7 +412,7 @@ namespace SqlSugar
 
         public bool Any()
         {
-            return this.Count()>0;
+            return this.Count() > 0;
         }
 
         public ISugarQueryable<TResult> Select<T2, TResult>(Expression<Func<T2, TResult>> expression)
@@ -450,6 +467,7 @@ namespace SqlSugar
             QueryBuilder.IsCount = true;
             var sql = QueryBuilder.ToSqlString();
             var reval = Context.Ado.GetInt(sql, QueryBuilder.Parameters.ToArray());
+            RestoreMapping();
             QueryBuilder.IsCount = false;
             return reval;
         }
@@ -530,6 +548,7 @@ namespace SqlSugar
         public KeyValuePair<string, List<SugarParameter>> ToSql()
         {
             string sql = QueryBuilder.ToSqlString();
+            RestoreMapping();
             return new KeyValuePair<string, List<SugarParameter>>(sql, QueryBuilder.Parameters);
         }
 
@@ -542,6 +561,7 @@ namespace SqlSugar
         public DataTable ToDataTable()
         {
             var sqlObj = this.ToSql();
+            RestoreMapping();
             var result = this.Db.GetDataTable(sqlObj.Key, sqlObj.Value.ToArray());
             return result;
         }
@@ -632,6 +652,7 @@ namespace SqlSugar
                 }
                 if (this.Context.CurrentConnectionConfig.IsAutoCloseConnection) this.Context.Close();
             }
+            RestoreMapping();
             return result;
         }
         private List<string> GetPrimaryKeys()
@@ -656,6 +677,13 @@ namespace SqlSugar
                 return this.EntityInfo.Columns.Where(it => it.IsIdentity).Select(it => it.DbColumnName).ToList();
             }
         }
+        private void RestoreMapping()
+        {
+            if (IsAs)
+            {
+                this.Context.MappingTables = OldMappingTableList;
+            }
+        }
         #endregion
     }
 }

SqlSugar/Abstract/UpdateProvider/UpdateableProvider.cs

@@ -22,12 +22,23 @@ namespace SqlSugar
         public List<MappingColumn> MappingColumnList { get; set; }
         private List<string> IgnoreColumnNameList { get; set; }
         private bool IsOffIdentity { get; set; }
+        public MappingTableList OldMappingTableList { get; set; }
+        public bool IsAs { get; set; }
         public int ExecuteCommand()
         {
             PreToSql();
-            return this.Ado.ExecuteCommand(UpdateBuilder.ToSqlString(), UpdateBuilder.Parameters == null ? null : UpdateBuilder.Parameters.ToArray());
+            string sql = UpdateBuilder.ToSqlString();
+            RestoreMapping();
+            return this.Ado.ExecuteCommand(sql, UpdateBuilder.Parameters == null ? null : UpdateBuilder.Parameters.ToArray());
+        }
+        public IUpdateable<T> AS(string tableName)
+        {
+            var entityName = typeof(T).Name;
+            IsAs = true;
+            this.Context.MappingTables = this.Context.RewritableMethods.TranslateCopy(this.Context.MappingTables);
+            this.Context.MappingTables.Add(entityName, tableName);
+            return this; ;
         }
-
         public IUpdateable<T> IgnoreColumns(Func<string, bool> ignoreColumMethod)
         {
             this.UpdateBuilder.DbColumnInfoList = this.UpdateBuilder.DbColumnInfoList.Where(it => !ignoreColumMethod(it.PropertyName)).ToList();
@@ -59,6 +70,7 @@ namespace SqlSugar
         {
             PreToSql();
             string sql = UpdateBuilder.ToSqlString();
+            RestoreMapping();
             return new KeyValuePair<string, List<SugarParameter>>(sql, UpdateBuilder.Parameters);
         }
 
@@ -234,5 +246,12 @@ namespace SqlSugar
                 return this.EntityInfo.Columns.Where(it => it.IsIdentity).Select(it => it.DbColumnName).ToList();
             }
         }
+        private void RestoreMapping()
+        {
+            if (IsAs)
+            {
+                this.Context.MappingTables = OldMappingTableList;
+            }
+        }
     }
 }

SqlSugar/Interface/IDeleteable.cs

@@ -10,6 +10,7 @@ namespace SqlSugar
     public interface IDeleteable<T> where T : class, new()
     {
         int ExecuteCommand();
+        IDeleteable<T> AS(string tableName);
         IDeleteable<T> With(string lockString);
         IDeleteable<T> Where(T deleteObj);
         IDeleteable<T> Where(Expression<Func<T, bool>> expression);

SqlSugar/Interface/IQueryable.cs

@@ -12,6 +12,8 @@ namespace SqlSugar
         SqlSugarClient Context { get; set; }
         ISqlBuilder SqlBuilder { get; set; }
 
+        ISugarQueryable<T> AS<T2>(string tableName);
+        ISugarQueryable<T> AS(string tableName);
         ISugarQueryable<T> With(string withString);
         ISugarQueryable<T> AddParameters(object pars);
         ISugarQueryable<T> AddParameters(SugarParameter[] pars);

SqlSugar/Interface/IUpdateable.cs

@@ -10,6 +10,7 @@ namespace SqlSugar
     public interface IUpdateable<T>
     {
         int ExecuteCommand();
+        IUpdateable<T> AS(string tableName);
         IUpdateable<T> With(string lockString);
         IUpdateable<T> Where(bool isUpdateNull,bool IsOffIdentity = false);
         IUpdateable<T> Where(Expression<Func<T, bool>> expression);

SqlSugar/Interface/Insertable.cs

@@ -11,6 +11,7 @@ namespace SqlSugar
     {
         int ExecuteCommand();
         int ExecuteReutrnIdentity();
+        IInsertable<T> AS(string tableName);
         IInsertable<T> With(string lockString);
         IInsertable<T> InsertColumns(Expression<Func<T, object>> columns);
         IInsertable<T> IgnoreColumns(Expression<Func<T, object>> columns);