插入语句常用写法：

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.打开这个网页PlanetB;

方法2.或者谷歌搜索syntax highlight code in word documents，检索结果的第一个。如下图：



PS. 方法1和2打开的为同一个网站。

二、步骤

1.将你需要插入在word中的代码完整的复制到该网站提示的文本框内，选择你的代码类型，如C,C++,HTML等，并点击提交。如下图：





2.该网页会自动将该代码生成到一个新的页面，此时ctrl+A全选，后ctrl+c复制到word中粘贴就好。如下图：



三、体验

以下为本次实验代码在word中的对比图。

1.和单纯的复制粘贴相比



2.和简单的加入一个灰色无边框的1*1表格相比



PS.由于此次测试使用的代码并不是用常见的语言编写的，所以并没有起到很好的代码高亮作用，在word中还会出现英语的语法错误。

可在word中设置仅对该文档不使用语法检查。下图为关闭语法错误提示后的效果对比。

使用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图：