插入语句常用写法：
 
INSERT INTO items(name,city,price,number,picture)  VALUES('耐克运动鞋','广州',500,1000,'003.jpg');
 
这种方式只能够一次插入一条数据，要想插入多条数据，就得多次调用此sql语句，意味着多次与数据库建立连接。但是这样一来，就会增加服务器的负荷，因为，执行每一次SQL服务器都要同样对SQL进行分析、优化等操作。幸好MySQL提供了另一种解决方案，就是使用一条INSERT语句来插入多条记录。这并不是标准的SQL语法，因此只能在MySQL中使用。
 
 
 
 一条INSERT语句插入批量数据的写法：
 
INSERT INTO 

[表名]([列名],[列名]) 

 VALUES

([列值],[列值])),

([列值],[列值])),

([列值],[列值]));
 
可以看到，和原来的常规INSERT语句的区别，仅仅是在VALUES 后面增加值的排列，每条记录之间用英文输入法状态下的逗号隔开，是不是so easy。
 
示例：
 
INSERT INTO 

items(name,city,price,number,picture) 

VALUES

('耐克运动鞋','广州',500,1000,'003.jpg'),

('耐克运动鞋2','广州2',500,1000,'002.jpg');
 
这样，就实现了一次性插入了2条数据。
 
建议：
 
在程序中，插入批量数据时，最好使用这种通过一条INSERT语句来一次性插入的方式。这样可以避免程序和数据库建立多次连接，从而增加服务器负荷。
 
 
 
欢迎关注微信公众号（Java修炼记）：
 
专注Java技术积累，免费分享Java技术干货、学习笔记、学习资料等，致力于让这里成为一个java知识小站。
 

分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 
 
/*
 * 直接插入排序（straight insertion sort）的做法是：
 * 每次从无序表中取出第一个元素，把它插入到有序表的合适位置使有序表仍然有序，直至无序表中所有元素插入完为止。
 * 第一趟扫描前两个数，然后把第二个数按大小顺序插入到有序表中；
 * 第二趟把第三个数与前两个数从前向后扫描，把第三个数按大小插入到有序表中；
 * 依次进行下去，进行了（n-1）趟扫描以后就完成了整个排序过程。
 * 
 * 直接插入排序属于稳定的排序，最坏时间复杂度为O（n^2），空间复杂度为O（1）。
 * 
 * 直接插入排序是由两层嵌套循环组成的。
 * 外层循环标识并决定待比较的数值，内层循环为待比较数值确定其最终位置。
 * 直接插入排序是将待比较的数值与它的前一数值进行比较，所以外层循环是从第二个数值开始的。
 * 当前一数值比待比较数值大的情况下后移该数值并继续循环比较，
 * 直到找到比待比较数值小的并将待比较数值插入其后一位置，结束该次循环。
 * 值得注意的是，我们必需用一个存储空间来保存当前待比较的数值，
 * 因为当一趟比较完成时，我们要将待比较数值插入比它小的数值的后一位置。
 * 插入排序类似于玩纸牌时整理手中纸牌的过程。
*/

namespace InsertionSort
{
    using System;

    /// <summary>
    /// The program.
    /// </summary>
    public static class Program
    {
        /// <summary>
        /// The main.
        /// </summary>
        public static void Main()
        {
            int[] a = {1, 4, 6, 2, 8, 7, 9, 3, 5, 10};

            Console.WriteLine("Before Insertion Sort:");
            foreach (int i in a)
            {
                Console.Write(i + " ");
            }

            Console.WriteLine("\r\n\r\nIn Insertion Sort:");
            InsertionSort(a);

            Console.WriteLine("\r\nAfter Insertion Sort:");
            foreach (int i in a)
            {
                Console.Write(i + " ");
            }
        }

        /// <summary>
        /// The insertion sort.
        /// </summary>
        /// <param name="a">
        /// The a.
        /// </param>
        public static void InsertionSort(int[] a)
        {
            // 从第二个元素开始迭代。
            for (int i = 1; i < a.Length; i++)
            {
                // 存储待插入的元素。
                int tmp = a[i];
                int j = i - 1;

                // 从当前元素右边寻找插入点。
                while (a[j] > tmp)
                {
                    // 后移。
                    a[j + 1] = a[j];
                    j--;
                    if (j == -1)
                    {
                        break;
                    }
                }

                // 该后移的元素已经后移了，会留下一个空位置，这个位置就是待插入元素的插入点。
                a[j + 1] = tmp;

                // 打印数组。
                foreach (int k in a)
                {
                    Console.Write(k + " ");
                }

                Console.WriteLine(string.Empty);
            }
        }
    }
}

// Output:
/*
Before Insertion Sort:
1 4 6 2 8 7 9 3 5 10

In Insertion Sort:
1 4 6 2 8 7 9 3 5 10
1 4 6 2 8 7 9 3 5 10
1 2 4 6 8 7 9 3 5 10
1 2 4 6 8 7 9 3 5 10
1 2 4 6 7 8 9 3 5 10
1 2 4 6 7 8 9 3 5 10
1 2 3 4 6 7 8 9 5 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10

After Insertion Sort:
1 2 3 4 5 6 7 8 9 10
*/
 
 

 
 
1.各大培训机构，价格10万的视频 Java架构师视频免费送
 
 
2.各种电子书籍经典Java书籍免费送
 
 
3.关注下方我的公众号进行免费获取
 
 
 
MySQL中添加或插入语句(Insert)的几种使用方式
 
1.INSERT 简写方式插入数据(不推荐)
 
 
 
1.先看一下表中有那些数据
 
 
 
 
 
2.使用Inset into 表名 values(值1,值2)进行插入,并对查看插入数据是否成功
 
 

 　　注意:insert这种简写的方式虽然非常简单,但是Values后面的值必须和表中的类顺序对应,且类型要保持一直,即使表中某一个列不需要值也必须赋值为null,比如我们的主键id设置的是递增实际上是不用设置值的,但是使用这种方式必须赋值为null
 　　不推荐的原因:在实际开发中如果使用此方法进行插入数据,后面表进行了改动(比如字段顺序改变了)那么整个语句都将报错,扩展性及其差,且维护起来比较困难
 
2.INSERT 完整写法(推荐)
 
 
 
1.使用Inset into 表名(字段1,字段2) values(值1,值2)进行插入,并对查看插入数据是否成功
 
 

 　　推荐使用的原因:这一次我们设置了没有给id赋任何值包括null,而且不用关心表中字段的顺序,比如下面不按照正常顺序添加,我们将age放在第一,name放在第二个.也能添加成功;需要注意的是表名后面的字段名必须和后面values赋的值保持一致;实际开发中在维护和扩张方面都比方案一要好.　
 
 
3.REPLACE INSERT语句
 
 
 
此语句的作用是当我们在插入一条数据时，如果此条已经存在，那么先删除原来存在的数据再添加插入的数据，如果不存在那么直接插入新的数据。注意：却分是否存在是通过主键来确定的
 
 
 
4.INSERT IGNORE INTO 语句
 
 
 
此语句的作用是如果插入的数据已经存在那么就忽略插入的数据（也就是不改变原来的数据），如果不存在则插入新的数据。
 注意：却分是否存在是通过主键来确定的
 
 
 
5.INSERT 批量插入
 
 
 
1.使用Inset into 表名(字段1,字段2,字段3) values(值1,值2,值3);Inset into 表名(字段1,字段2,字段3) values(值1,值2,值3)进行插入,并对查看插入数据是否成功
 
 
 
 
 
2.使用简写方式使用Inset into 表名(字段1,字段2,字段3) values(值1,值2,值3),(值1,值2,值3)进行插入,并对查看插入数据是否成功,必须保证values后的值都和字段相对应.
 
 
 
6.INSERT SELECT语句
 
 
 
1.此语句的作用是将SELECT语句的结果插入表中,可实现数据迁移
 2.语法:insert into 插入的表名(字段1,字段2,字段3) select 被查询的字段1,被查询的字段2 from 被查询的表名;
 3.先查看需要插入的表的所有数据
 
 
 
 
 
４.查看被插入的表的所有数据
 
 
 
 
 
5.执行INSERT SELECT语句并查看结果
 
 
 
 
 
1.各大培训机构，价格10万的视频 Java架构师视频免费送
 
 
2.各种电子书籍经典Java书籍免费送
 
 
3.关注下方我的公众号进行免费获取
 
 

使用mybatis插入数据执行效率对比，对比三种方式（测试数据库为MySQL），
 
1 使用 SqlSessionFactory，每一批数据执行一次提交
 
2 使用mybatis-plus框架的insert方法，for循环，每次执行一次插入
 
3 使用ibatis，纯sql插入
 
新增xml执行效率测试：xml执行时间比sql稍慢一些，50000条数据插入时间约为2000毫秒左右，平均时间是sql的2倍左右。
 
先贴出执行效果（数字代表执行的时间，单位毫秒）：
 
 
 
 
 
 
测试代码：
 
//测试类
@RunWith(SpringRunner.class)
@SpringBootTest(classes = DemoApplication.class)
public class Test1 {

    @Autowired
    UsersMapper usersMapper;

    @Autowired
    SqlSessionFactory sqlSessionFactory;
    public List<Users> list = new ArrayList<>();

    @Before
    public void  getList() {
        long start = System.currentTimeMillis();
        Users user;
        for (int i = 1; i <=50000 ; i++) {
            user = new Users();
            user.setId(i);
            user.setName("java");
            user.setAge(200);
            user.setManagerId(222);
            list.add(user);
        }
        System.out.println("拼装数据 耗时："+(System.currentTimeMillis()-start));
        System.out.println(list.size());
    }


    @Test
    public void batchInsert() {
        SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH,false);
        UsersMapper mapper = sqlSession.getMapper(UsersMapper.class);
        System.out.println("batchInsert 插入开始========");
        long start = System.currentTimeMillis();
        for (int i = 0; i < list.size(); i++) {
            mapper.insert(list.get(i));
            if (i%5000==4999) {
                sqlSession.flushStatements();
//                sqlSession.commit();
//                sqlSession.clearCache();
            }
        }
//        sqlSession.commit();
//        sqlSession.clearCache();
        sqlSession.flushStatements();
        System.out.println("SqlSession 批量插入耗时："+(System.currentTimeMillis()-start));
    }

    @Test
    public void forEachInsert() {
        System.out.println("forEachInsert 插入开始========");
        long start = System.currentTimeMillis();
        for (int i = 0; i < list.size(); i++) {
            usersMapper.insert(list.get(i));
        }
        System.out.println("foreach 插入耗时："+(System.currentTimeMillis()-start));
    }

    @Test
    public void sqlInsert() {
        System.out.println("sql 插入开始========");
        long start = System.currentTimeMillis();
        usersMapper.sqlInsert(list);
        System.out.println("sql 插入耗时："+(System.currentTimeMillis()-start));
    }
//xml批量插入

    @Test
    public void xmlInsert() {
        System.out.println("xmlInsert 批量插入开始========");
        long start = System.currentTimeMillis();
        usersMapper.xmlBatchInsert(list);
        System.out.println("xmlInsert 批量插入耗时："+(System.currentTimeMillis()-start));
    }

}

//sql插入相关类
@Repository
public interface UsersMapper extends BaseMapper<Users> {

    @InsertProvider(type = UsersProvider.class, method = "insertListSql")
    public void sqlInsert(List<Users> list);

    public void xmlBatchInsert(@Param("list") List<Users> list);
}

public class UsersProvider {

    public String insertListSql(List<Users> list) {
        StringBuffer sqlList = new StringBuffer();

        sqlList.append(" INSERT INTO users(id,name,age,manager_id)  VALUES ");
        for (int i = 0; i < list.size() ; i++) {
            Users user = list.get(i);
            sqlList.append(" (").append(user.getId()).append(",").append("'").append(user.getName()).append("',").append(user.getAge())
                    .append(",").append(user.getManagerId()).append(")");
            if (i < list.size()-1) {
                sqlList.append(",");
            }
        }
        return sqlList.toString();
    }
}

//xml 插入mapper文件

<?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="com.example.demo.dao.UsersMapper">

  <insert id="xmlBatchInsert">
    INSERT INTO users(id,name,age,manager_id)  VALUES
    <foreach collection="list" item="item" index="index" separator=",">
      (#{item.id},
      #{item.name},
      #{item.age},
      #{item.managerId})
    </foreach>
  </insert>
</mapper>
 
总结：
 
sql插入的效率最高，sqlsession次之，mybatis框架foreach插入效率最低。
 
执行效率echarts图：