精华内容
下载资源
问答
  • 动态批量删除SQL数据库中的表

    千次阅读 2016-01-05 14:55:37
     在项目需求中需要用到动态批量删除数据库中的表  1、需要的参数 数据库的名称 需要删除的表名list,EF实体名称  底层封装好的SQLhelper类,代码如下: using System; using System.Collections; using...

       

       引言


       在项目需求中需要用到动态批量的删除数据库中的表,我们都知道在数据库中的数据是需要历史记录的所以我


    们这所谓的删除其实只是给它重命名然后打上时间戳,这样就可以标志着这个数据表在数据库中已经没有用了,但是


    其中的数据还是有用的,下面和大家分享这几天在项目中学习到的东西!!


       底层封装好的SQLhelper类,代码如下:


    <span style="font-size:18px;">using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Configuration;
    using System.Data;
    using System.Data.SqlClient;
    using System.Linq;
    using System.Text;
    using System.Transactions;
    
    namespace ITOO.Library.Core.Common
    {
        /// <summary>
        /// 数据库助手类
        /// </summary>
        public class SQLHelper
        {
            private SqlCommand cmd = null;
            private SqlConnection conn = null;
            private SqlDataReader sdr = null;
    
            /// <summary>
            /// 
            /// </summary>
            /// <param name="strDatabaseName"></param>
            /// <param name="IsGetNewConnection"></param>
            public SQLHelper(string strDatabaseName, bool IsGetNewConnection = false)
            {
                if (IsGetNewConnection == false)
                {
                    conn = ConnectionFactory.GetCurrentConn(strDatabaseName);
                }
                else
                {
                    conn = ConnectionFactory.GetNewConn(strDatabaseName);
                }
            }
    
            /// <summary>
            /// 无参构造函数
            /// </summary>
            public SQLHelper()
            {
            }
    
            private SqlConnection GetConnection(string strDatabaseName)
            {
                string strConnValue = ConfigHelper.ReadAppSetting(strDatabaseName);
                return new SqlConnection(strConnValue);
            }
    
            /// <summary>
            /// 获得数据库连接
            /// </summary>
            /// <returns></returns>
            private SqlConnection GetConnection()
            {
                if (conn.State == ConnectionState.Closed)
                {
                    conn.Open();
                }
                return conn;
            }
    
            /// <summary>
            /// 关闭连接
            /// </summary>
            /// <param name="conn">数据库连接</param>
            public static void Close(SqlConnection conn)
            {
                if (conn != null)
                {
                    try
                    {
                        conn.Close();
                    }
                    catch (SqlException e)
                    {
                        throw e;
                    }
                }
            }
    
            /// <summary>
            /// 执行带参数的增删改命令
            /// </summary>
            /// <param name="cmmText"></param>
            /// <param name="para"></param>
            /// <param name="cmmType"></param>
            /// <returns></returns>
            public int ExecuteNonQuery(string cmmText, SqlParameter[] para, CommandType cmmType)
            {
                cmd = new SqlCommand(cmmText, GetConnection());
                cmd.CommandType = cmmType;
    
                try
                {
                    cmd.Parameters.AddRange(para);
                    return cmd.ExecuteNonQuery();
                }
                catch (SqlException e)
                {
                    throw e;
                }
            }
    
            /// <summary>
            /// 执行不带参数的增删改命令
            /// </summary>
            /// <param name="cmmText"></param>
            /// <param name="cmmType"></param>
            /// <returns></returns>
            public int ExecuteNonQuery(string cmmText, CommandType cmmType)
            {
                cmd = new SqlCommand(cmmText, GetConnection());
                cmd.CommandType = cmmType;
    
                try
                {
                    return cmd.ExecuteNonQuery();
                }
                catch (SqlException e)
                {
                    throw e;
                }
            }
    
            /// <summary>
            /// 执行带参数的查询命令
            /// </summary>
            /// <param name="cmmText"></param>
            /// <param name="para"></param>
            /// <param name="cmmType"></param>
            /// <returns></returns>
            public DataTable ExecuteQuery(string cmmText, SqlParameter[] para, CommandType cmmType)
            {
                DataTable dt = new DataTable();
                cmd = new SqlCommand(cmmText, GetConnection());
                cmd.CommandType = cmmType;
                cmd.Parameters.AddRange(para);
    
                try
                {
                    using (sdr = cmd.ExecuteReader(CommandBehavior.CloseConnection))
                    {
                        dt.Load(sdr);
                        return dt;
                    }
                }
                catch (SqlException e)
                {
                    throw e;
                }
            }
    
            /// <summary>
            /// 执行不带参数的查询命令
            /// </summary>
            /// <param name="cmmText"></param>
            /// <param name="cmmType"></param>
            /// <returns></returns>
            public DataTable ExecuteQuery(string cmmText, CommandType cmmType)
            {
                DataTable dt = new DataTable();
                cmd = new SqlCommand(cmmText, GetConnection());
                cmd.CommandType = cmmType;
                using (sdr = cmd.ExecuteReader(CommandBehavior.CloseConnection))
                {
                    dt.Load(sdr);
                }
                return dt;
            }
    
            /// <summary>
            /// 执行创建表的方法
            /// 先读取文件,以GO为段落,把每一个GO的段落当做一条SQL命令,在通过事务一起执行。
            /// </summary>
            /// <param name="varSqlList">传入执行的sql脚本</param>
            public void ExecuteCommand(ArrayList varSqlList)
            {
                SqlTransaction varTrans = GetConnection().BeginTransaction();
                cmd = new SqlCommand();
                cmd.Connection = GetConnection();
                cmd.Transaction = varTrans;
                try
                {
                    foreach (string varcommandText in varSqlList)
                    {
                        cmd.CommandText = varcommandText;
                        cmd.ExecuteNonQuery();
                    }
                    varTrans.Commit();
                }
                catch (Exception ex)
                {
                    varTrans.Rollback();
                    throw ex;
                }
            }
    
            #region 批量导入DataTable
    
            /// <summary>
            /// 批量导入DataTable
            /// </summary>
            /// <param name="strDatabaseName">配置文件key</param>
            /// <param name="dt">datatable名称</param>
            /// <param name="tableName">表名称</param>
            /// <param name="dtColum">所有列(dt.columns)</param>
            /// <returns>返回true,or false</returns>
            public Boolean InsertTable(string strDatabaseName, DataTable dt, string tableName, DataColumnCollection dtColum)
            {
                using (TransactionScope scope1 = new TransactionScope(TransactionScopeOption.Required))
                {
                    using (SqlBulkCopy sqlBC = new SqlBulkCopy(
                               GetConnection(strDatabaseName).ConnectionString, SqlBulkCopyOptions.KeepIdentity))
                    {
                        sqlBC.BatchSize = 1000;
                        sqlBC.DestinationTableName = tableName;
    
                        // Write from the source to the destination.
                        // This should fail with a duplicate key error.
                        for (int i = 0; i < dtColum.Count; i++)
                        {
                            sqlBC.ColumnMappings.Add(dtColum[i].ColumnName.ToString(), dtColum[i].ColumnName.ToString());
                        }
                        try
                        {
                            //批量写入
                            sqlBC.WriteToServer(dt);
                            scope1.Complete();
                            return true;
                        }
                        catch
                        {
                            throw new Exception("导入数据失败!");
                        }
                    }
                }
            }
    
            #endregion 批量导入DataTable
        }</span>


         删除 数据表的方法


    <span style="font-size:18px;">  /// <summary>
            /// 批量假删除数据表(重命名,打上时间戳)
            /// </summary>
            /// <param name="db">指定的数据库</param>
            /// <param name="listDt">要删除的数据库表集合</param>
            /// <param name="connKey">数据库连接串</param>
            /// <returns>执行是否成功,true表示成功,false表示失败</returns>
            public bool FalseDropTable(string db, List<string> listDt, string connKey)
            {
                SQLHelper helper = null;
                try
                {
                     helper = new SQLHelper("ITOOExamEntities");
                }
                catch (Exception e)
                {
    
                    throw e;
                }
               
    
                string connToMaster = ConfigurationManager.ConnectionStrings[connKey].ToString();
    
                //判断数据库是否存在
                if (IsDBExist(db, connKey) == false)
                {
                    throw new Exception("数据库不存在!");
                }
    
                string timeStamp = DateTime.Now.ToString();            // 2008-9-4 20:02:10
    
                for (int i = 0; i < listDt.Count(); i++)
                {
                    //如果数据库表存在,则抛出错误
                    if (IsTableExist(db, listDt[i], connKey) == false)
                    {
                        //如果数据库表已经删除,则跳过该表
                        continue;
                    }
                    else//数据表存在,则进行删除数据表
                    {
                        //其后判断数据表是否存在,然后创建数据表
                        //string createTableStr = "use " + db + " drop table " + listDt[i] + " ";
                        string createTableStr = "use " + db + " exec sp_rename '" + listDt[i] + "','" + listDt[i] + "_" + timeStamp + "'";
                        helper.ExecuteNonQuery(createTableStr, CommandType.Text);
                    }
                }
                return true;
            }</span>

        判断指定的数据库是否存在


     

    <span style="font-size:18px;">/// <summary>
            /// 判断数据库是否存在
            /// </summary>
            /// <param name="db">数据库的名称</param>
            /// <param name="connKey">数据库的连接Key</param>
            /// <returns>true:表示数据库已经存在;false,表示数据库不存在</returns>
            public Boolean IsDBExist(string db, string connKey)
            {
                SQLHelper helper = new SQLHelper("ITOOExamEntities");
    
                string connToMaster = ConfigurationManager.ConnectionStrings[connKey].ToString();
                string createDbStr = " select * from master.dbo.sysdatabases where name " + "= '" + db + "'";
    
                DataTable dt = helper.ExecuteQuery(createDbStr, CommandType.Text);
                if (dt.Rows.Count == 0)
                {
                    return false;
                }
                else
                {
                    return true;
                }
            }</span>

      判断数据库中的指定的表是否存在


    <span style="font-size:18px;">/// <summary>
            /// 判断数据库表是否存在
            /// </summary>
            /// <param name="db">数据库</param>
            /// <param name="tb">数据表名</param>
            /// <param name="connKey">连接数据库的key</param>
            /// <returns>true:表示数据表已经存在;false,表示数据表不存在</returns>
            public Boolean IsTableExist(string db, string tb, string connKey)
            {
                SQLHelper helper = new SQLHelper("ITOOExamEntities");
    
                string connToMaster = ConfigurationManager.ConnectionStrings[connKey].ToString();
                string createDbStr = "use " + db + " select 1 from  sysobjects where  id = object_id('" + tb + "') and type = 'U'";
    
                //在指定的数据库中  查找 该表是否存在
                DataTable dt = helper.ExecuteQuery(createDbStr, CommandType.Text);
                if (dt.Rows.Count == 0)
                {
                    return false;
                }
                else
                {
                    return true;
                }
    
            }</span>

        以上是小编在刚接手的项目中学习到的一些对于自己来说比较新的东西,在这分享给大家,希望能给大家带来帮


    助!!


    展开全文
  • mybatis动态Sql实现批量添加和批量删除: 新建一个domainMapper接口: 接下来写:domainMapper.xml配置,在本利中即:UserMapper.xml &lt;?xml version="1.0" encoding="UTF-8" ?&gt; &...

    mybatis动态Sql实现批量添加和批量删除:
    新建一个domainMapper接口:
    在这里插入图片描述接下来写:domainMapper.xml配置,在本利中即:UserMapper.xml

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <!--
    namespace:命名空间 -> 要求:一个项目中命名空间必须唯一;
    一般:domain的路径来唯一
    -->
    <mapper namespace="cn.itsource.mybatis.batch_options.UserMapper">
        <!--
          select:标签名字:  CRUD的时候对应的名字
          id:这个语句的唯一标识;   【必须和接口的方法名字一样】;
          parameterType:传入参数类型
          resultType:返回值类型
          #{id}:参数的接收
    
          collection=""  遍历集合
          index=""  遍历时候的索引
          item=""   每此遍历得到的对象
          open=""   以什么开始
          close=""  以什么结束
          separator="" 以什么作为分割符
        -->
        <select id="saveBatch" parameterType="list">
    
            INSERT INTO user (username,password) VALUES
    
            <foreach collection="list" item="user" separator=",">
                (#{user.username},#{user.password})
            </foreach>
    
        </select>
    
    
        <delete id="deleteBatch" parameterType="list">
    
            delete from user where id in
    
            <foreach collection="list" item="id" open="(" close=")" separator=",">
                #{id}
            </foreach>
    
        </delete>
    </mapper>
    

    注意在mybatis的主配置文件中,引入该UserMapper.xml文件:
    在这里插入图片描述自定义工具类获得SqlSession对象:
    在这里插入图片描述

    测试:
    在这里插入图片描述

    展开全文
  • Mybatis动态SQl之批量删除

    千次阅读 2019-01-04 20:11:12
    * 方法描述:根据ids集合进行删除 * @return */ int deleteByIds(List&lt;Integer&gt; ids); 二、Mapper.xml动态sql collection:传递来的参数,可以是list,array(数组),还可以是map的key,可以是pojo中的...

    一、首先要有mapper接口

    /**
    * 
    * 方法描述:根据ids集合进行删除
    * @return
    */
    int deleteByIds(List<Integer> ids);

    二、Mapper.xml动态sql

    collection:传递来的参数,可以是list,array(数组),还可以是map的key,可以是pojo中的属性
             item:循环中的当前元素
             index:当前元素的下标
             open:循环的开始
             close:循环的结束
             separator:分隔符

    <delete id="deleteByIds" parameterType="list">
    	delete from user where id in
    	<foreach collection="list" item="id" open="(" close=")" separator=",">
    		#{id}
    	</foreach>
    </delete>

     这段SQL最终会被自动组合成:delete from user where id in ( ? , ? ) 

    三、测试

    public class TestMapper {
    	public static void main(String[] args) {
    		//1.获取会话
    		SqlSession sqlSession = SqlSessionFactoryUtil.getFactory().openSession();
    		//2.获取mapper接口的代理对象
    		UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    		List<Integer> ids = new ArrayList<>();
    		//添加要删除的id
    		ids.add(22);
    		ids.add(23);
    		//调用mapper动态SQL的批量删除
    		userMapper.deleteByIds(ids);
    		sqlSession.commit();
    	}
    }

     

    展开全文
  • Mybatis 使用动态语句实现批量删除(delete结合foreach)

    Mybatis 使用动态语句实现批量删除(delete结合foreach)


    在下面的案例本人将演示如何使用动态语句批量删除数据库数据,本人在数据库建了一张emp员工表(表的数据自己填充),表的结构如下:


    批量删除的核心代码为,在实体映射文件中配置如下的代码:

    <!-- 批量删除 -->
    	<delete id="deleteMoreEmp" parameterType="int[]">
    		<!-- delete from emp where empno in(7789,7790) -->
    		<!-- forEach : 用来循环 collection : 用来指定循环的数据的类型 可以填的值有:array,list,map item 
    			: 循环中为每个循环的数据指定一个别名 index : 循环中循环的下标 open : 开始 close : 结束 separator : 数组中元素之间的分隔符 -->
    		delete from emp where empno in
    		<foreach collection="array" item="arr" index="no" open="("
    			separator="," close=")">
    			#{arr}
    		</foreach>
    	</delete>

    下面是项目的结构(本人使用的是maven搭建的web项目):



    IEmpDAO.java为接口提供批量删除数据方法,EmpDAOImpl.java为接口的实现类,MybatisSqlSessionFactory.java为本人创建的获取sqlSession的工具类,Emp.java为实体类,Emp.xml为映射文件,mybatis_cfg.xml为mybatis主配置文件,Test.java为测试类,pom.xml为maven引入依赖的文件。

    1、IEmpDAO.java为接口提供批量删除数据方法

    /**
    	 * 批量删除
    	 * 
    	 * @param arr
    	 * @return
    	 */
    	public boolean doRemoveeMore(int[] arr);
     传入的参数为emp的主键数组。

    2、EmpDAOImpl.java为接口的实现类

    	public boolean doRemoveeMore(int[] arr) {
    		SqlSession sqlSession = null;
    		try {
    			sqlSession = MybatisSqlSessionFactory.getMySqlSession();
    			int result = sqlSession.delete("cn.sz.hcq.pojo.Emp.deleteMoreEmp",
    					arr);
    			sqlSession.commit();
    			return result > 0 ? true : false;
    		} catch (Exception e) {
    			e.printStackTrace();
    			sqlSession.rollback();
    		} finally {
    			MybatisSqlSessionFactory.closeSqlSession();
    		}
    		return false;
    	}

    3、MybatisSqlSessionFactory.java为本人创建的获取sqlSession的工具类

    package cn.sz.hcq.factory;
    
    import java.io.IOException;
    import java.io.Reader;
    
    import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    
    public class MybatisSqlSessionFactory {
    	// 配置文件
    	private static final String RESOURCE = "mybatis_cfg.xml";
    	private static Reader reader = null;
    	private static SqlSessionFactoryBuilder builder = null;
    	private static SqlSessionFactory factory = null;
    	// 可以在同一个线程范围内,共享一个对象
    	private static ThreadLocal<SqlSession> threadLocal = new ThreadLocal<SqlSession>();
    
    	// 静态代码块(类加载的时候执行一次)
    	static {
    		try {
    			reader = Resources.getResourceAsReader(RESOURCE);
    			builder = new SqlSessionFactoryBuilder();
    			factory = builder.build(reader);
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    
    	public static SqlSession getMySqlSession() {
    		// 从本地线程中获取session连接
    		SqlSession sqlSession = threadLocal.get();
    		// 连接为空则创建连接,并将该连接添加到本地线程中去
    		if (sqlSession == null) {
    			if (factory == null) {
    				rebuildFactory();
    			}
    			sqlSession = factory.openSession();
    		}
    		threadLocal.set(sqlSession);
    		return sqlSession;
    	}
    
    	// 创建工厂
    	public static void rebuildFactory() {
    		try {
    			reader = Resources.getResourceAsReader(RESOURCE);
    			builder = new SqlSessionFactoryBuilder();
    			factory = builder.build(reader);
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    
    	// 关闭连接
    	public static void closeSqlSession() {
    		SqlSession sqlSession = threadLocal.get();
    		if (sqlSession != null) {
    			// 关闭session
    			sqlSession.close();
    		}
    		// 同时将本地线程中置为null(防止用户再次调用时出现空的session)
    		threadLocal.set(null);
    	}
    
    }
    


    4、Emp.java为实体类

    public class Emp implements Serializable {
    	private Integer empno;
    	private String ename;
    	private String job;
    	private Integer mgr;
    	private Date hiredate;
    	private Double sal;
    	private Double comm;
    	private Integer deptno;
    
    	public Integer getEmpno() {
    		return empno;
    	}
    
    	public void setEmpno(Integer empno) {
    		this.empno = empno;
    	}
    
    	public String getEname() {
    		return ename;
    	}
    
    	public void setEname(String ename) {
    		this.ename = ename;
    	}
    
    	public String getJob() {
    		return job;
    	}
    
    	public void setJob(String job) {
    		this.job = job;
    	}
    
    	public Integer getMgr() {
    		return mgr;
    	}
    
    	public void setMgr(Integer mgr) {
    		this.mgr = mgr;
    	}
    
    	public Date getHiredate() {
    		return hiredate;
    	}
    
    	public void setHiredate(Date hiredate) {
    		this.hiredate = hiredate;
    	}
    
    	public Double getSal() {
    		return sal;
    	}
    
    	public void setSal(Double sal) {
    		this.sal = sal;
    	}
    
    	public Double getComm() {
    		return comm;
    	}
    
    	public void setComm(Double comm) {
    		this.comm = comm;
    	}
    
    	public Integer getDeptno() {
    		return deptno;
    	}
    
    	public void setDeptno(Integer deptno) {
    		this.deptno = deptno;
    	}
    
    }
    


    5、Emp.xml为映射文件

    <?xml version="1.0" encoding="UTF-8"?>
     <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
    		"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="cn.sz.hcq.pojo.Emp">
    	<!-- 批量删除 -->
    	<delete id="deleteMoreEmp" parameterType="int[]">
    		<!-- delete from emp where empno in(7789,7790) -->
    		<!-- forEach : 用来循环 collection : 用来指定循环的数据的类型 可以填的值有:array,list,map item 
    			: 循环中为每个循环的数据指定一个别名 index : 循环中循环的下标 open : 开始 close : 结束 separator : 数组中元素之间的分隔符 -->
    		delete from emp where empno in
    		<foreach collection="array" item="arr" index="no" open="("
    			separator="," close=")">
    			#{arr}
    		</foreach>
    	</delete>
    </mapper>

    6、mybatis_cfg.xml为mybatis主配置文件

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    		"http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
    	<!--数据源 -->
    	<environments default="myconn">
    		<environment id="myconn">
    			<!--事务管理方式 -->
    			<transactionManager type="JDBC"></transactionManager>
    			<!--数据库连接参数 -->
    			<dataSource type="POOLED">
    				<!-- type:数据源连接的方式 ,POOLED:连接池方式, UNPOOLED: 非连接池的方式 ,JNDI:java命名与目录接口方式 -->
    				<property name="driver" value="org.gjt.mm.mysql.Driver"></property>
    				<property name="url" value="jdbc:mysql://localhost:3306/db"></property>
    				<property name="username" value="root"></property>
    				<property name="password" value="root"></property>
    			</dataSource>
    		</environment>
    	</environments>
    
    	<!-- 引入实体映射文件 -->
    	<mappers>
    		<mapper resource="cn/sz/hcq/pojo/Emp.xml" />
    	</mappers>
    	<!-- 配置的参数 -->
    </configuration>
    


    7、pom.xml为maven引入依赖的文件

    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    	<modelVersion>4.0.0</modelVersion>
    	<groupId>cn.sz.hcq.pro</groupId>
    	<artifactId>Mybatis_04</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<packaging>war</packaging>
    	<dependencies>
    		<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
    		<dependency>
    			<groupId>org.mybatis</groupId>
    			<artifactId>mybatis</artifactId>
    			<version>3.2.3</version>
    		</dependency>
    		<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
    		<dependency>
    			<groupId>mysql</groupId>
    			<artifactId>mysql-connector-java</artifactId>
    			<version>5.1.39</version>
    		</dependency>
    	</dependencies>
    </project>


    8、Test.java为测试类

    public class Test {
    	public static void main(String[] args) {
    		IEmpDAO empDAO = new EmpDAOImpl();
    		System.out.println("----------批量删除----------");
    		int[] arr = { 7791, 7792 };//删除的主键
    		boolean removeeMore = empDAO.doRemoveeMore(arr);
    		System.out.println("批量删除的结果:" + removeeMore);
    	}
    }
    
    

    完成代码后,运行测试类就可以完成批量删除。

    展开全文
  • Mybatis注解 实现动态SQL,批量删除

    千次阅读 2019-12-10 16:15:38
    Mybatis注解 实现动态SQL 以前学习mybatis的时候,基本是在xml里编写sql语句,感觉在xml也还算方便吧。动态sql,参数类都是好管理的。但是,xml对于长sql友好,对短sql就不太友好了。我们写的时候写完接口方法,还是...
  • ASP批量删除源码,JS实现表格动态排序
  • Hive批量删除一段时间分区和动态分区更新数据 1.hive动态分区 -- 批量删除分区数据 alter table dm.dm_call_gateway_bill_time_detail drop partition(dt >="20191101",dt <='20191130') -- 开启动态分区 SET...
  • 动态添加js,动态添加表格和删除表格,批量添加记录,批量添加
  • ssm批量删除

    千次阅读 2018-01-03 20:10:53
    最近要实现一个功能,效果图如下,当点击最上方复选框可以实现总控制全选和取消操作,然后点击批量删除按钮可以实现删除所选中的数据行 环境说明采用ssm集合框架,配置部分不罗列 Dao层question.xml delete from ...
  • 今天在写业务代码时,需要写一个删除数据库记录的方法。然而要操作的表被其他的表依赖。也就是本表的主键是其他表的外键。但是数据库并没有设计外键,所以只能手动删除关联表的信息 。用的框架是spring,dubbo,...
  • mybatis高级版 利用动态sql片段加入 foreach 循环拼接 实现 单表进行批量查询、批量修改、批量删除、批量添加。 第一步建表 以员工表单表为例 create table emp1( id varchar2(20) primary key, name varchar2...
  • js实现批量删除功能

    2020-10-14 20:36:59
    主要为大家详细介绍了js实现批量删除功能,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 百家批量删除插件

    2018-12-14 10:38:45
    批量删除百家号文章,方便省事,,
  • 批量删除

    2013-08-04 23:40:48
    通常drop table语法一次只能删除一个表,如果要同时删除几个表,可以通过用动态SQL来进行批量处理。  方法很简单,就是先从user_tables或其他表中查找出表名,然后删除;   begin for i in (select table_name ...
  • 【教程】批量删除B站抽奖动态

    千次阅读 2020-08-20 18:56:57
    删除参与抽奖的动态不影响其他内容,直接上教程 1.在登录状态下打开我的动态页面 B站 我的动态页面 https://space.bilibili.com/ 2.复制下面这段脚本代码 // 复制这段代码 var needDelDeled = true, delay ...
  • ajax实现批量删除

    千次阅读 2018-09-28 20:45:37
    这几天一直在学习ajax,实现了用ajax来批量删除数据。 HTML &lt;thead&gt; &lt;tr&gt; &lt;th class="table-check"&gt; &lt;input id="allchk" onclick=&...
  • Mybatis动态SQL 条件查询,批量删除

    千次阅读 2017-04-29 17:02:01
    比如说某宝的搜索。可以添加选择的嘛。...mybatis就有动态sql。根据条件组合sql语句。 首先创建个前端页面<!DOCTYPE html> <title>hight_search.html</title> <meta http-equiv="keywords" conte
  • mybatis 批量删除

    千次阅读 2013-09-21 21:27:22
    mybatis 批量删除  目前项目组持久层用的是 MyBatis 3(v 3.0.4),很多页面涉及到批量删除,查阅了一下myBatis 官方文档,文当中提到需要在MyBatis 的实体配置文件中配置一个元素, 就是该元素。下面给出文档中...
  • 一:监听复选框事件 var checkedArr=[]; table.on('checkbox(demo)', function(obj){ if (obj.type=='all') return; if (obj.checked){ checkedArr.push(obj.data.LAY_TABLE_INDEX);... //checkedArr[obj.data.id] = ...
  • MaBatis:使用foreach进行批量插入和批量删除 foreach可以在SQL语句中通过拼接的方式进行集合迭代。foreach元素的属性主要有collection,item,index,separator,open,close。 1.item属性:表示循环体中的具体对象...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 66,091
精华内容 26,436
关键字:

动态批量删除