[置顶] 如何数据库表数据导出到excel中

摘要： 1.首先须要有一个NPOI2.接下来上代码 1 private void button1_Click(object sender, EventArgs e) 2 { 3 //1.通过Ado.net读取数据 4 string sql = "SELECT * FROM ASRS_F1"; 5 ... 阅读全文

posted @ 2015-09-11 16:47 学无止境_上海 阅读(1154) 评论(0) 推荐(0) 编辑

2024年3月15日

C# 使用SqlSugar搭建数据仓库

通过NuGet获取SqlSugar

SqlsugarClient访问类

    public class SugarFactory
    {
        private static string strConnectionString = string.Empty;
 
        #region 数据库访问对象
 
        /// <summary>
        /// 数据库访问对象
        /// </summary>
        private static SqlSugarClient db = null;
 
        #endregion 数据库访问对象
 
        #region 私有构造函数，禁止实例化
 
        //私有构造函数，禁止实例化
        private SugarFactory()
        {
        }
 
        #endregion 私有构造函数，禁止实例化
 
        #region 初始化SqlSugarClient
 
        /// <summary>
        /// 初始化SqlSugarClient
        /// </summary>
        /// <returns>返回SqlSugarClient对象</returns>
        public static SqlSugarClient GetInstance()
        {
            if (strConnectionString == string.Empty)
            {
                strConnectionString = "Data Source=192.168.4.61;Initial Catalog=ReportServer;User ID=sa;Password=123456";
 
            }
 
            db = new SqlSugarClient(new ConnectionConfig()
            {
                ConnectionString = strConnectionString,
                DbType = DbType.SqlServer,
                IsAutoCloseConnection = true
            }); 
 
            return db;
        }
 
        #endregion 初始化SqlSugarClient
    }

 数据访问仓库接口类

 

/// <summary>
    /// 数据访问仓库接口
    /// </summary>
    /// <typeparam name="TEntity">实体类型</typeparam>
    public interface IRepositoryBase<TEntity> where TEntity : class
    {
        /// <summary>
        /// 获取数据库操作实例
        /// </summary>
        /// <returns>返回连接对象</returns>
        SqlSugarClient GetInstance();
 
        /// <summary>
        /// 插入实体 忽略NULL
        /// </summary>
        /// <param name="entity">实体对象</param>
        /// <returns>插入成功返回true</returns>
        bool Insert(TEntity entity);
 
        /// <summary>
        /// 插入实体,返回自增列的值
        /// </summary>
        /// <param name="entity">实体对象</param>
        /// <returns>插入成功返回true</returns>
        int InsertReturnIdentity(TEntity entity);
 
        /// <summary>
        /// 插入实体，返回自增列的值
        /// </summary>
        /// <param name="entity">实体对象</param>
        /// <returns>插入成功返回true</returns>
        long InsertReturnBigIdentity(TEntity entity);
 
        /// <summary>
        /// 根据唯一主键删除
        /// </summary>
        /// <param name="keyValue">唯一主键</param>
        /// <returns>删除成功返回true</returns>
        bool Delete(object keyValue);
 
        /// <summary>
        /// 根据表达式删除
        /// </summary>
        /// <param name="expression">表达式</param>
        /// <returns>删除成功返回true</returns>
        bool Delete(Expression<Func<TEntity, bool>> expression);
        /// <summary>
        /// 将实体对象更新到数据库 忽略属性为NULL
        /// </summary>
        /// <param name="entity">必需包含主键并且不能为匿名对象</param>
        /// <returns>更新成功返回true</returns>
        bool Update(TEntity entity);
 
        /// <summary>
        /// 更新或者写入
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        TEntity UpdateOrInsert(TEntity entity);
 
        /// <summary>
        /// 检测主键对应的数据是否存在
        /// </summary>
        /// <param name="ID">主键值</param>
        /// <returns>存在返回true,不存在返回false</returns>
        bool IsExist(int ID);
 
        /// <summary>
        /// 检测主键对应的数据是否存在
        /// </summary>
        /// <param name="ID">主键值</param>
        /// <returns>存在返回true,不存在返回false</returns>
        bool IsExist(string ID);
 
        /// <summary>
        /// 根据主键查询对象实体
        /// </summary>
        /// <param name="keyValue">主键</param>
        /// <returns>实体</returns>
        TEntity FindEntity(object keyValue);
 
        /// <summary>
        /// 根据条件查询第一条数据
        /// </summary>
        /// <param name="expression">表达式</param>
        /// <returns>实体</returns>
        TEntity FindFirst(Expression<Func<TEntity, bool>> expression);
        /// <summary>
        /// 查找符合表达式的List集合
        /// </summary>
        /// <param name="expression">表达式</param>
        /// <returns>实体集合</returns>
        List<TEntity> FindList(Expression<Func<TEntity, bool>> expression);
        /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <returns></returns>
        List<TEntity> FindAllList();
 
        /// <summary>
        /// 查找符合表达式的List集合
        /// </summary>
        /// <returns>实体集合</returns>
        List<TEntity> GetList(string strsql);
 
        /// <summary>
        /// 查找符合表达式的List集合
        /// </summary>
        /// <param name="intTop">前几行</param>
        /// <param name="expression">表达式</param>
        /// <returns>实体集合</returns>
        List<TEntity> FindTopList(int intTop, Expression<Func<TEntity, bool>> expression);
 
        /// <summary>
        /// 获得记录数
        /// </summary>
        /// <param name="pageWhere">查询条件</param>
        /// <param name="tableName">查询的表名</param>
        /// <returns>返回ListModel</returns>
        int GetListCount(string pageWhere, string tableName);
 
        /// <summary>
        /// 获得分页数据
        /// </summary>
        /// <param name="pageSize">每页数量</param>
        /// <param name="pageIndex">第几页</param>
        /// <param name="pageWhere">查询条件</param>
        /// <param name="pageOrder">排序</param>
        /// <param name="tableName">查询的表名</param>
        /// <returns>返回ListModel</returns>
        List<TEntity> GetListPageData(int pageSize, int pageIndex, string pageWhere, string pageOrder, string tableName);
 
        /// <summary>
        /// 获取满足表达式的记录条数
        /// </summary>
        /// <param name="expression">表达式</param>
        /// <returns></returns>
        int FindCount(Expression<Func<TEntity, bool>> expression);
    }

仓库基类

/// <summary>
    /// 仓储基类
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    public class RepositoryBase<TEntity> : IRepositoryBase<TEntity> where TEntity : class, new()
    {
        /// <summary>
        /// 获取数据库实例，公开只要是想在外部直接是用
        /// </summary>
        /// <returns>返回连接对象</returns>
        public SqlSugarClient GetInstance()
        {
            return SugarFactory.GetInstance();
        }
 
        /// <summary>
        /// 插入实体 忽略NULL
        /// 对于自增列的值赋值没有意义，赋值和不赋值运行效果一样
        /// </summary>
        /// <param name="entity">实体对象</param>
        /// <returns>插入成功返回true</returns>
        public virtual bool Insert(TEntity entity)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Insertable(entity).ExecuteCommand() > 0;
                }
            }
            catch (Exception ex)
            {
                return false;
            }
        }
 
        /// <summary>
        /// 插入实体,返回自增列的值
        /// 对于自增列的值赋值没有意义，赋值和不赋值运行效果一样
        /// </summary>
        /// <param name="entity">实体对象</param>
        /// <returns>插入成功返回true</returns>
        public virtual int InsertReturnIdentity(TEntity entity)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Insertable(entity).ExecuteReturnIdentity();
                }
            }
            catch (Exception ex)
            {
                return 0;
            }
        }
 
        /// <summary>
        /// 插入实体，返回自增列的值
        /// 对于自增列的值赋值没有意义，赋值和不赋值运行效果一样
        /// </summary>
        /// <param name="entity">实体对象</param>
        /// <returns>插入成功返回true</returns>
        public virtual long InsertReturnBigIdentity(TEntity entity)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Insertable(entity).ExecuteReturnBigIdentity();
                }
            }
            catch (Exception ex)
            {
                return 0;
            }
        }
 
        /// <summary>
        /// 根据唯一主键删除
        /// 主键不存在，为False 
        /// </summary>
        /// <param name="keyValue">唯一主键</param>
        /// <returns>删除成功返回true</returns>
        public virtual bool Delete(object keyValue)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Deleteable<TEntity>().In(keyValue).ExecuteCommand() > 0;
                }
            }
            catch (Exception ex)
            {
                return false;
            }
        }
 
        /// <summary>
        /// 根据表达式删除
        /// </summary>
        /// <param name="expression">表达式</param>
        /// <returns>删除成功返回true</returns>
        public virtual bool Delete(Expression<Func<TEntity, bool>> expression)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Deleteable<TEntity>().Where(expression).ExecuteCommand() > 0;
                }
            }
            catch (Exception ex)
            {
                return false;
            }
        }
 
        /// <summary>
        /// 将实体对象更新到数据库 忽略属性为NULL
        /// 主键在数据库里不存在则返回False
        /// 没有主键则返回False
        /// </summary>
        /// <param name="entity">必需包含主键并且不能为匿名对象</param>
        /// <returns>更新成功返回true</returns>
        public virtual bool Update(TEntity entity)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Updateable(entity).ExecuteCommand() > 0;
                }
            }
            catch (Exception ex)
            {
                return false;
            }
        }
 
        /// <summary>
        /// 将实体对象更新到数据库 忽略属性为NULL
        /// 修改主键不存在的，会新增（不包括主键的）该信息
        /// 没有主键的修改，则新增该信息
        /// </summary>
        /// <param name="entity">必需包含主键并且不能为匿名对象</param>
        /// <returns>更新成功返回true</returns>
        public virtual TEntity UpdateOrInsert(TEntity entity)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Saveable<TEntity>(entity).ExecuteReturnEntity();
                }
            }
            catch (Exception ex)
            {
                return null;
            }
        }
 
        /// <summary>
        /// 检测主键对应的数据是否存在
        /// </summary>
        /// <param name="ID">主键值</param>
        /// <returns>存在返回true,不存在返回false</returns>
        public bool IsExist(int ID)
        {
            bool ReturnResult = false;
 
            using (var db = GetInstance())
            {
                List<TEntity> list = db.Queryable<TEntity>().In(new int[] { ID }).ToList();
                if (list != null)
                {
                    if (list.Count == 0)
                    {
                        ReturnResult = false;
                    }
                    else
                    {
                        ReturnResult = true;
                    }
                }
                else
                {
                    ReturnResult = false;
                }
            }
 
            return ReturnResult;
        }
 
        /// <summary>
        /// 检测主键对应的数据是否存在
        /// </summary>
        /// <param name="ID">主键值</param>
        /// <returns>存在返回true,不存在返回false</returns>
        public bool IsExist(string ID)
        {
            bool ReturnResult = false;
 
            using (var db = GetInstance())
            {
                List<TEntity> list = db.Queryable<TEntity>().In(new string[] { ID }).ToList();
                if (list != null)
                {
                    if (list.Count == 0)
                    {
                        ReturnResult = false;
                    }
                    else
                    {
                        ReturnResult = true;
                    }
                }
                else
                {
                    ReturnResult = false;
                }
            }
 
            return ReturnResult;
        }
 
        /// <summary>
        /// 根据主键查询对象实体
        /// </summary>
        /// <param name="keyValue">主键</param>
        /// <returns>实体</returns>
        public virtual TEntity FindEntity(object keyValue)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Queryable<TEntity>().InSingle(keyValue);
                };
            }
            catch (Exception ex)
            {
                return null;
            }
        }
 
        /// <summary>
        /// 根据条件查询第一条数据
        /// </summary>
        /// <returns>实体</returns>
        public virtual TEntity FindFirst(Expression<Func<TEntity, bool>> expression)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Queryable<TEntity>().Where(expression).First();
                };
            }
            catch (Exception ex)
            {
                return null;
            }
        }
 
        /// <summary>
        /// 查找符合表达式的List集合
        /// </summary>
        /// <param name="expression">表达式</param>
        /// <returns>实体集合</returns>
        public virtual List<TEntity> FindList(Expression<Func<TEntity, bool>> expression)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Queryable<TEntity>().Where(expression).ToList();
                };
            }
            catch (Exception ex)
            {
                return new List<TEntity>();
            }
        }
 
        /// <summary>
        /// 
        /// </summary>
        /// <param name="expression"></param>
        /// <returns></returns>
        public virtual List<TEntity> FindListReturnNull(Expression<Func<TEntity, bool>> expression)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Queryable<TEntity>().Where(expression).ToList();
                };
            }
            catch (Exception ex)
            {
                return null;
            }
        }
 
        /// <summary>
        /// 查找所有List集合
        /// </summary>
        /// <returns>实体集合</returns>
        public virtual List<TEntity> FindAllList()
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Queryable<TEntity>().ToList();
                };
            }
            catch (Exception ex)
            {
                return new List<TEntity>();
            }
        }
 
        /// <summary>
        /// 查找符合条件的实体集合
        /// </summary>
        /// <param name="strsql">sql语句</param>
        /// <returns>实体集合</returns>
        public virtual List<TEntity> GetList(string strsql)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Queryable<TEntity>().Where(strsql).ToList();
                };
            }
            catch (Exception ex)
            {
                return new List<TEntity>();
            }
        }
 
        /// <summary>
        /// 查找符合表达式的List集合
        /// </summary>
        /// <param name="intTop">前几行</param>
        /// <param name="expression">表达式</param>
        /// <returns>实体集合</returns>
        public virtual List<TEntity> FindTopList(int intTop, Expression<Func<TEntity, bool>> expression)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Queryable<TEntity>().Take(intTop).Where(expression).ToList();
                };
            }
            catch (Exception ex)
            {
                return new List<TEntity>();
            }
        }
 
        #region 获得记录数
        /// <summary>
        /// 获得记录数
        /// 不是本表的也可以进行查询，但是建议只查本表的
        /// 
        /// </summary>
        /// <param name="pageWhere">查询条件</param>
        /// <param name="tableName">查询的表名 </param>
        /// <returns>返回ListModel</returns>
        public int GetListCount(string pageWhere, string tableName)
        {
            int ReturnVale = 0;
 
            using (var db = GetInstance())
            {
                try
                {
                    StringBuilder strSql = new StringBuilder();
                    strSql.Append("select * from " + tableName);
                    if (pageWhere.Trim() != "")
                    {
                        strSql.Append(" where " + pageWhere);
                    }
 
                    ReturnVale = db.Ado.GetInt(DataAdapterHelper.CreateCountSQL(tableName, pageWhere));
                }
                catch
                {
 
                }
            }
 
            return ReturnVale;
        }
        #endregion
 
        /// <summary>
        /// 获得分页数据
        /// pageSize小于0返回空，等于0返回全部
        /// pageIndex小于1则返回第一页，大于最大页数返回最后一页
        /// pageWhere必填项，不可为"",可写为1=1
        /// pageOrder必填项，不可为"",可写为 1（等数字）或者 ID （可倒序排列 ID desc）
        /// tableName必填项，不可写其他表名
        /// </summary>
        /// <param name="pageSize">每页数量</param>
        /// <param name="pageIndex">第几页</param>
        /// <param name="pageWhere">查询条件</param>
        /// <param name="pageOrder">排序</param>
        /// <param name="tableName">查询的表名</param>
        /// <returns>返回ListModel</returns>
        public List<TEntity> GetListPageData(int pageSize, int pageIndex, string pageWhere, string pageOrder, string tableName)
        {
            List<TEntity> ListData = new List<TEntity>();
 
            using (var db = GetInstance())
            {
                try
                {
                    StringBuilder strSql = new StringBuilder();
                    strSql.Append("select * from " + tableName);
                    if (pageWhere.Trim() != "")
                    {
                        strSql.Append(" where " + pageWhere);
                    }
 
                    int totalCount = 0;
                    totalCount = db.Ado.GetInt(DataAdapterHelper.CreateCountSQL(tableName, pageWhere));
                    ListData = db.Ado.SqlQuery<TEntity>(DataAdapterHelper.CreatePageSQL(totalCount, pageSize, pageIndex, strSql.ToString(), pageOrder, tableName));
                }
                catch (Exception ex)
                {
 
                }
            }
 
            return ListData;
        }
 
        /// <summary>
        /// 获取满足表达式的记录条数
        /// </summary>
        /// <param name="expression">表达式</param>
        /// <returns></returns>
        public int FindCount(Expression<Func<TEntity, bool>> expression)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Queryable<TEntity>().Count(expression);
                };
            }
            catch (Exception ex)
            {
                return -1;
            }
        }
    }

DataAdapterHelper帮助类：

/// <summary>
    /// 单表管理帮助类
    /// </summary>
    public class DataAdapterHelper
    {
        #region 获取记录总数SQL语句
        /// <summary>
        /// 获取记录总数SQL语句
        /// </summary>
        /// <param name="tableName">表名</param>
        /// <param name="pageWhere">条件</param>
        /// <returns>返回SQL语句</returns>
        public static string CreateCountSQL(string tableName, string pageWhere)
        {
            string ReturnValue = string.Empty;
            ReturnValue = SqlServerHelper.CreateCountSQL(tableName, pageWhere);
 
            return ReturnValue;
        }
        #endregion
 
        #region 获取分页SQL语句
        /// <summary>
        /// 获取分页SQL语句
        /// </summary>
        /// <param name="totalCount">记录总数</param>
        /// <param name="pageSize">每页记录数</param>
        /// <param name="pageIndex">当前页数</param>
        /// <param name="pageWhere">查询条件</param>
        /// <param name="pageOrder">排序</param>
        /// <param name="tableName">表名</param>
        /// <returns>返回SQL语句</returns>
        public static string CreatePageSQL(int totalCount, int pageSize, int pageIndex, string pageWhere, string pageOrder, string tableName)
        {
            string ReturnValue = string.Empty;
            ReturnValue = SqlServerHelper.CreatePageSQL(totalCount, pageSize, pageIndex, pageWhere, pageOrder, tableName);
 
            return ReturnValue;
        }
        #endregion
    }

SqlServerHelper帮助类：

    /// <summary>
    /// 单表管理数据操作类
    /// </summary>
    public class SqlServerHelper
    {
        #region 获取记录总数SQL语句
        /// <summary>
        /// 获取记录总数SQL语句
        /// </summary>
        /// <param name="tableName">表名</param>
        /// <param name="pageWhere">条件</param>
        /// <returns>返回SQL语句</returns>
        public static string CreateCountSQL(string tableName, string pageWhere)
        {
            return string.Format("SELECT COUNT(1) FROM {0} WHERE {1}", tableName, pageWhere);
        }
        #endregion
 
        #region 获取分页SQL语句
        /// <summary>
        /// 获取分页SQL语句
        /// </summary>
        /// <param name="totalCount">记录总数</param>
        /// <param name="pageSize">每页记录数</param>
        /// <param name="pageIndex">当前页数</param>
        /// <param name="pageWhere">查询条件</param>
        /// <param name="pageOrder">排序</param>
        /// <param name="tableName">表名</param>
        /// <returns>返回SQL语句</returns>
        public static string CreatePageSQL(int totalCount, int pageSize, int pageIndex, string pageWhere, string pageOrder, string tableName)
        {
            //计算总页数
            pageSize = pageSize == 0 ? totalCount : pageSize;
            int pageCount = (totalCount + pageSize - 1) / pageSize;
 
            //检查当前页数
            if (pageIndex < 1)
            {
                pageIndex = 1;
            }
            else if (pageIndex > pageCount)
            {
                pageIndex = pageCount;
            }
            //拼接SQL字符串，加上ROW_NUMBER函数进行分页
            StringBuilder newSafeSql = new StringBuilder();
            newSafeSql.AppendFormat("SELECT ROW_NUMBER() OVER(ORDER BY {0}) as row_number,", pageOrder);
            newSafeSql.Append(pageWhere.Substring(pageWhere.ToUpper().IndexOf("SELECT") + 6));
 
            //拼接成最终的SQL语句
            StringBuilder sbSql = new StringBuilder();
            sbSql.Append("SELECT * FROM (");
            sbSql.Append(newSafeSql.ToString());
            sbSql.Append(") AS T");
            sbSql.AppendFormat(" WHERE row_number between {0} and {1}", ((pageIndex - 1) * pageSize) + 1, pageIndex * pageSize);
 
            return sbSql.ToString();
        }
        #endregion
    }

调用测试：

根据数据库创建表的对应实体类Student，查询调用：

            RepositoryBase<Student> student= new RepositoryBase<Student>();
            var model= student.FindAllList();

 

posted @ 2024-03-15 10:18 学无止境_上海 阅读(601) 评论(0) 推荐(0) 编辑

2022年12月5日

.net core 远程下载文件并保存到对应的服务器

摘要： [HttpGet,Route("FileDownSave")] public async Task<CustomResponse<ResultCode>> FileDownSave() { CustomResponse < ResultCode > res = new(); var edi_File 阅读全文

posted @ 2022-12-05 18:23 学无止境_上海 阅读(954) 评论(0) 推荐(0) 编辑

2022年10月9日

MySQL慢查询优化

摘要： 数据库优化，Mysql 阅读全文

posted @ 2022-10-09 16:48 学无止境_上海 阅读(57) 评论(0) 推荐(0) 编辑

2017年8月8日

C#自动更新本地程序

摘要： 关于系统的自动更新。近日有一情况是需要将java端后台最新版本的系统文件覆盖本地客户端，简称自动更新了。 本地会获取当前系统的版本号去请求后台java的接口数据。返回给我的是后台压缩包转的base64字节流。 客户端拿到新版本需要更新本地程序。 这里是拿到的字节流了。 这个方法可以解决在同一个解决方 阅读全文

posted @ 2017-08-08 13:58 学无止境_上海 阅读(2560) 评论(0) 推荐(0) 编辑

2017年4月5日

将base64编码转换图片

摘要： /// /// 二进制Base64编码转图片 /// /// /// public string ByteToPicture(string bytes) { string[] urls = bytes.Split(','); strin... 阅读全文

posted @ 2017-04-05 16:58 学无止境_上海 阅读(453) 评论(0) 推荐(0) 编辑

2017年3月24日

bootstrap suggest搜索建议插件

摘要： 近日因工作需要看了下此插件。 首先下载bootstrap js包。添加此插件的引用。注意css样式要引用，不能忘记。 前台页面代码，因为楼主做的是选项卡切换查询不同的结果。 这是楼主根据不同的选项请求查询不同的数据，再在结果中搜索 下面说的就是第二种，是搜索插件内部的请求。 如下： 对应的后台代码： 阅读全文

posted @ 2017-03-24 11:52 学无止境_上海 阅读(12805) 评论(2) 推荐(1) 编辑

2017年3月22日

asp.net上传图片，上传图片

摘要： 想必很多人工作中经常需要实现上传图片的功能。 先引用此插件 http://files.cnblogs.com/files/hmYao/jquery-form.js。 前台代码 对应的后台代码如下： 有一点很重要，很多人都拿不到上传的路径值。注意参数的名称 需要和 file标签的name相同。 到此结 阅读全文

posted @ 2017-03-22 10:15 学无止境_上海 阅读(5245) 评论(3) 推荐(0) 编辑

2017年2月28日

时间戳转换为时间格式，时间格式转换为时间戳

摘要： --在sql中将时间戳转换为时间类型 --在sql中将时间戳转换为时间类型 SQL里面有个DATEADD的函数。时间戳就是一个从1970-01-01 08:00:00到时间的相隔的秒数。所以只要把这个时间戳加上1970-01-01 08:00:00这个时间就可以得到你想要的时间了select DAT 阅读全文

posted @ 2017-02-28 17:25 学无止境_上海 阅读(5068) 评论(0) 推荐(0) 编辑

2017年2月22日

sql插入临时表数据的方法

摘要： 方法有两种，主要看需求。 方法1：定义好临时表的字段和类型、插入对应的值 方法2：直接将查询出来的表数据插入临时表中 欢迎顶.... 阅读全文

posted @ 2017-02-22 11:58 学无止境_上海 阅读(14831) 评论(0) 推荐(0) 编辑

2017年2月17日

bootstrap中模态框、模态框的属性

摘要： 工作中有需要用到模态框的可以看看 其中模态框有个属性可以避免点击遮罩层导致模态框关闭。就是div中设置的 data-backdrop="static"。这样可以避免在模态框中输入内容时突然的误操作导致模态框关闭。 另外还有一个属性：data-keyboard="false"。此举是设置按下ESC退出 阅读全文

posted @ 2017-02-17 11:18 学无止境_上海 阅读(3565) 评论(0) 推荐(0) 编辑

下一页

导航

< 2025年3月 >
日 一 二 三 四 五 六
23 24 25 26 27 28 1
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30 31 1 2 3 4 5
点击右上角即可分享
微信分享提示