精华内容
下载资源
问答
  • 2021-11-09 11:58:24

    我们在开发的时候有时需要插入大量的测试数据,那怎么样才能更快速的进行插入操作呢,今天在这记录一下用sql来进行插入操作:

    
    -- 插入一百万条数据
    DELIMITER $$  -- 写函数之前必须要写 标记
    CREATE FUNCTION mock_data () RETURNS INT 
    BEGIN
      DECLARE num INT DEFAULT 1000000 ;DECLARE i INT DEFAULT 0 ;
      WHILE
        i < num DO 
        INSERT INTO table_name (column1,column2..) VALUES(value1,value2..);
        SET i = i + 1 ;
      END WHILE ;
      RETURN i ;
    END ;
    
      
        
          
          
        
      

    更多相关内容
  • MySQL插入1000000条数据只花了6秒钟! 关键点: 1.使用PreparedStatement对象 2.rewriteBatchedStatements=true 开启批量插入插入只执行一次,所有插入比较快。 二、 代码 package test0823.demo1; ...
  • 一、编写测试案例向MySQL数据库中插入百万条数据。测试数据表建表脚本如下:use db_xk; drop table if exists tb_test2; create table tb_test2 ( id int primary key auto_increment, subject varchar(50) ...
  • 目录1、多线程插入(单表)2、多线程插入(多表)3、预处理SQL4、多值插入SQL5、事务(N提交一次)多线程插入(单表)问:为何对同一个表的插入多线程会比单线程快?同一时间对一个表的写操作不应该是独占的吗?答:在数据...

    e08e8ff1f85630bb57f2f55be027ff84.png

    目录

    1、多线程插入(单表)

    2、多线程插入(多表)

    3、预处理SQL

    4、多值插入SQL

    5、事务(N条提交一次)

    多线程插入(单表)

    问: 为何对同一个表的插入多线程会比单线程快? 同一时间对一个表的写操作不应该是独占的吗?

    答:在数据里做插入操作的时候,整体时间的分配是这样的:

    1、多链接耗时 (30%)

    2、多发送query到服务器 (20%)

    3、多解析query (20%)

    4、多插入操作 (10% * 词条数目)

    5、多插入index (10% * Index的数目)

    6、多关闭链接 (10%)

    从这里可以看出来,真正耗时的不是操作,而是链接,解析的过程。

    MySQL插入数据在写阶段是独占的,但是插入一条数据仍然需要解析、计算、最后才进行写处理,比如要给每一条记录分配自增id,校验主键唯一键属性,或者其他一些逻辑处理,都是需要计算的,所以说多线程能够提高效率。

    多线程插入(多表)

    分区分表后使用多线程插入。

    预处理SQL

    普通SQL : 即使用Statement接口执行SQL

    预处理SQL : 即使用PreparedStatement接口执行SQL

    使用PreparedStatement接口允许数据库预编译SQL语句,以后只需传入参数,避免了数据库每次都编译SQL语句,因此性能更好。

    多值插入SQL

    普通插入SQL:INSERT INTO TBL_TEST (id) VALUES(1)

    多值插入SQL:INSERT INTO TBL_TEST (id) VALUES (1), (2), (3)

    使用多值插入SQL,SQL语句的总长度减少,即减少了网络IO,同时也降低了连接次数,数据库一次SQL解析,能够插入多条数据。

    事务(N条提交一次)

    在一个事务中提交大量INSERT语句可以提高性能。

    1、将表的存储引擎修改为myisam 2、将 sql 拼接成字符串,每 1000 条左右提交事务。

    执行多条SQL语句,实现数据库事务。

    mysql数据库

    多条SQL语句

    10w条数据大概用时10s!

    【编辑推荐】

    【责任编辑:张燕妮 TEL:(010)68476606】

    点赞 0

    展开全文
  • mysql数据库中导入100万条数据数据文件,往mysql数据库中导入100万条数据数据文件,往mysql数据库中导入100万条数据数据文件,往mysql数据库中导入100万条数据数据文件,往mysql数据库中导入100万条数据的...
  • ) ENGINE=InnoDB AUTO_INCREMENT=1048561 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci 方法1 单行插入 调用100万插入,耗时太长,插入7万已经耗时7分钟,所以直接就将程序暂停了 package dbTest;...

    数据库

    数据库版本:MySQL 8.0.27

    CREATE TABLE `product` (
      `pid` int NOT NULL AUTO_INCREMENT,
      `pname` varchar(64) DEFAULT NULL COMMENT '商品名',
      `price` double DEFAULT NULL COMMENT '价格',
      PRIMARY KEY (`pid`)
    ) ENGINE=InnoDB AUTO_INCREMENT=1048561 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci
    

    方法1 单行插入

    调用100万次插入,耗时太长,插入7万条已经耗时7分钟,所以直接就将程序暂停了

    package dbTest;
    import java.sql.*;
    
    public class jdbc1 {
        // JDBC driver name and database URL
        static final String JDBC_DRIVER = "com.mysql.cj.jdbc.Driver";
        static final String DB_URL = "jdbc:mysql://localhost:3306/online_store";
    
        //  Database credentials
        static final String USER = "root";
        static final String PASS = "123456";
    
        public static void main(String[] args) {
            Connection connection = null;
            Statement statement = null;
            try{
                //STEP 2: Register JDBC driver
                Class.forName(JDBC_DRIVER);
    
                //STEP 3: Open a connectionection
                System.out.println("connectionecting to a selected database...");
                connection = DriverManager.getConnection(DB_URL, USER, PASS);
    
                System.out.println("connectionected database successfully...");
    
                //STEP 4: Execute a query
                System.out.println("Inserting records into the table...");
                statement = connection.createStatement();
    
                for(int i =0; i<100_0000;i++){
                    String sql = "INSERT INTO product (pname,price) VALUES (\"pname1\", 33333.5)";
                    statement.executeUpdate(sql);
                    System.out.println("Inserted records into the table, count:" + i);
                }
            }catch(SQLException e){
                //Handle errors for JDBC
                e.printStackTrace();
            }catch(Exception e){
                //Handle errors for Class.forName
                e.printStackTrace();
            }finally{
                //finally block used to close resources
                try{
                    if(statement != null){
                        connection.close();
                    }
                }catch(SQLException e){
                }
                try{
                    if(connection != null){
                        connection.close();
                    }
                }catch(SQLException e){
                    e.printStackTrace();
                }
            }
    
            System.out.println("end");
        }
    }
    
    TRUNCATE TABLE product; //删除product表中的所有数据并释放空间,如果被其他表作为外键引用,需要先删除外键才可以,delete每次是单条删除,速度比较慢,而且不会释放空间,可以回滚
    

    方法2 批量预处理

    package dbTest;
    import java.sql.*;
    
    public class jdbc2 {
        // JDBC driver name and database URL
        static final String JDBC_DRIVER = "com.mysql.cj.jdbc.Driver";
        static final String DB_URL = "jdbc:mysql://localhost:3306/online_store";
    
        // Database credentials
        static final String USER = "root";
        static final String PASS = "123456";
    
        //插入的数据条数
        static final int InsertCounter = 1000000;
    
        public static void main(String[] args) {
            Connection connection = null;
            PreparedStatement statement = null;
            Long startTime = 0L;
            Long endTime = 0L;
    
            try{
                //STEP 2: Register JDBC driver
                Class.forName(JDBC_DRIVER);
    
                //STEP 3: Open a connectionection
                connection = DriverManager.getConnection(DB_URL, USER, PASS);
    
                //STEP 4: Execute a query
                //这里需要注意,SQL语句的格式必须是预处理的这种,就是values(?,?,...,?),否则批处理不起作用
                statement = connection.prepareStatement("INSERT INTO product (pname,price) VALUES (?, ?)");
    
                System.out.println("开始插入数据");
                startTime = System.currentTimeMillis();
    
                for (int i = 0; i < InsertCounter ; i++) {
                    statement.setString(1, "商品" + i);
                    statement.setInt(2, i);
                    //将要执行的SQL语句先添加进去,不执行
                    statement.addBatch();
                }
    
                //100W条SQL语句已经添加完成,执行这100W条命令并提交
                statement.executeBatch();
                connection.commit();
    
            }catch(SQLException e){
                //Handle errors for JDBC
                e.printStackTrace();
            }catch(Exception e){
                //Handle errors for Class.forName
                e.printStackTrace();
            }finally{
                //finally block used to close resources
                try{
                    if(statement != null){
                        connection.close();
                    }
                }catch(SQLException e){
    
                }
                try{
                    if(connection != null){
                        connection.close();
                    }
                }catch(SQLException e){
                    e.printStackTrace();
                }
            }
    
            endTime = System.currentTimeMillis();
            System.out.println(InsertCounter + "条数据插入完毕,用时:" + (endTime - startTime));
        }
    }
    

    耗时19分钟,看到网上说100w条数据几秒就能插入,我想是不是可以把自增id的约束取消掉,然后又试了试

    package dbTest;
    import java.sql.*;
    
    public class jdbc2 {
        // JDBC driver name and database URL
        static final String JDBC_DRIVER = "com.mysql.cj.jdbc.Driver";
        static final String DB_URL = "jdbc:mysql://localhost:3306/online_store";
    
        // Database credentials
        static final String USER = "root";
        static final String PASS = "123456";
    
        //插入的数据条数
        static final int InsertCounter = 1000000;
    
        public static void main(String[] args) {
            Connection connection = null;
            PreparedStatement statement = null;
            Long startTime = 0L;
            Long endTime = 0L;
    
            try{
                //STEP 2: Register JDBC driver
                Class.forName(JDBC_DRIVER);
    
                //STEP 3: Open a connectionection
                connection = DriverManager.getConnection(DB_URL, USER, PASS);
    
                //STEP 4: Execute a query
                //这里需要注意,SQL语句的格式必须是预处理的这种,就是values(?,?,...,?),否则批处理不起作用
                statement = connection.prepareStatement("INSERT INTO product (pid,pname,price) VALUES (?, ?, ?)");
    
                System.out.println("开始插入数据");
                startTime = System.currentTimeMillis();
    
                for (int i = 0; i < InsertCounter ; i++) {
                    statement.setLong(1, i);
                    statement.setString(2, "商品" + i);
                    statement.setInt(3, i);
                    //将要执行的SQL语句先添加进去,不执行
                    statement.addBatch();
                }
    
                //100W条SQL语句已经添加完成,执行这100W条命令并提交
                statement.executeBatch();
                connection.commit();
    
            }catch(SQLException e){
                //Handle errors for JDBC
                e.printStackTrace();
            }catch(Exception e){
                //Handle errors for Class.forName
                e.printStackTrace();
            }finally{
                //finally block used to close resources
                try{
                    if(statement != null){
                        connection.close();
                    }
                }catch(SQLException e){
    
                }
                try{
                    if(connection != null){
                        connection.close();
                    }
                }catch(SQLException e){
                    e.printStackTrace();
                }
            }
    
            endTime = System.currentTimeMillis();
            System.out.println(InsertCounter + "条数据插入完毕,用时:" + (endTime - startTime));
        }
    }
    

    实际耗时18分钟,所以主键递增好像也没有对性能造成什么影响

    方法3 Load Data

    准备数据文件

    package utils;
    
    import java.io.*;
    
    public class CSVTool {
        public static void main(String[] args) {
            String str = "pname1,123.2";
    
            Long startTime = System.currentTimeMillis();
    
            for(int i = 0; i < 1000000; i++){
                try{
                    write2File(str);
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
    
            Long endTime = System.currentTimeMillis();
    
            System.out.println("执行时间:" + (endTime-startTime));
        }
    
        public static void write2File(String str) throws IOException {
            File f = new File("D:\\222.csv");
            if (!f.exists()) {
                System.out.print("文件不存在");
                // 不存在则创建
                if(f.createNewFile()){
                    System.out.print("文件创建成功");
                }
            }
    
            //true,则追加写入text文本
            BufferedWriter output = new BufferedWriter(new FileWriter(f,true));
    
            output.write(str);
            output.write("\r\n");
            output.flush();
            output.close();
        }
    }
    

    耗时约两分钟

    使用LOAD DATA插入

    在这里插入图片描述
    在这里插入图片描述

    使用sqlyog导入

    在这里插入图片描述

    报错:Loading local data is disabled; this must be enabled on both the client and server sides

    SHOW VARIABLES LIKE "%local_infile%"
    
    SET GLOBAL local_infile = 1
    

    在这里插入图片描述

    因为没有时间提示,所以不知道确切的时间,但是感觉只有几秒,非常快,也可以用命令来导入;

    在这里插入图片描述

    LOAD DATA LOCAL INFILE  'd:\\222.csv'
    INTO TABLE product
    FIELDS TERMINATED BY ',' 
    ENCLOSED BY '"'
    LINES TERMINATED BY '\r\n'
    (pname,price);
    

    耗时5s

    官方文档《MySQL 8.0 Reference Manual》 ->SQL Statement->Data Manipulation Statements->LOAD DATA Statement

    在这里插入图片描述

    展开全文
  • 教你如何6秒钟往MySQL插入100万条数据

    千次阅读 多人点赞 2020-08-24 02:30:58
    MySQL插入1000000条数据只花了6秒钟! 关键点: 1.使用PreparedStatement对象 2.rewriteBatchedStatements=true 开启批量插入插入只执行一次,所有插入比较快。 二、 代码 package test0823.demo1; import ...

    一、思路

    往MySQL中插入1000000条数据只花了6秒钟!

    关键点:
    1.使用PreparedStatement对象
    在这里插入图片描述
    在这里插入图片描述

    2.rewriteBatchedStatements=true 开启批量插入,插入只执行一次,所有插入比较快。
    在这里插入图片描述

    二、 代码

    package test0823.demo1;
    
    import java.sql.*;
    
    /**
     * @author : Bei-Zhen
     * @date : 2020-08-24 0:43
     */
    public class JDBC2 {
    
        //static int count = 0;
    
        public static void main(String[] args) {
    
            long start = System.currentTimeMillis();
            conn();
            long end = System.currentTimeMillis();
            System.out.println("耗时:" + (end - start)/1000 + "秒");
        }
    
        public static void conn(){
            //1.导入驱动jar包
            //2.注册驱动(mysql5之后的驱动jar包可以省略注册驱动的步骤)
            //Class.forName("com.mysql.jdbc.Driver");
            //3.获取数据库连接对象
            Connection conn = null;
            PreparedStatement pstmt = null;
            {
                try {
                    //"&rewriteBatchedStatements=true",一次插入多条数据,只插入一次
                    conn = DriverManager.getConnection("jdbc:mysql:///test?" + "&rewriteBatchedStatements=true","root","root");
                    //4.定义sql语句
                    String sql = "insert into user values(default,?,?)";
                    //5.获取执行sql的对象PreparedStatement
                    pstmt = conn.prepareStatement(sql);
                    //6.不断产生sql
                    for (int i = 0; i < 1000000; i++) {
                        pstmt.setString(1,(int)(Math.random()*1000000)+"");
                        pstmt.setString(2,(int)(Math.random()*1000000)+"");
                        pstmt.addBatch();
                    }
                    //7.往数据库插入一次数据
                    pstmt.executeBatch();
                    System.out.println("添加1000000条信息成功!");
    
                } catch (SQLException e) {
                    e.printStackTrace();
                } finally {
                    //8.释放资源
                    //避免空指针异常
                    if(pstmt != null) {
                        try {
                            pstmt.close();
                        } catch (SQLException e) {
                            e.printStackTrace();
                        }
                    }
    
                    if(conn != null) {
                        try {
                            conn.close();
                        } catch (SQLException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
    
        }
    
    }
    
    

    三、运行结果

    添加1000000条信息成功!
    耗时:6

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 作为一个Java后台,MySQL的使用是家常便饭,虽然平常不会遇到几十甚至几百万的数据插入情况,但是耐不住我的好奇心,今天写几个方法用来测试一下 我们使用控制变量来对比出来最适合数据批量插入的条件 罗列一下...
  • 并且MySQL的版本是5.7.35,其他版本慎用 MySQL版本 SQLyog Navicat 问题注意:如果出现 FUNCTION mock_data already exists 错误 解决方法1: -- 使用sql语句执行删除函数操作 DROP FUNCTION mock_data; 解决方法2:...
  • 创建模拟测试数据,在编程过程中可能经常遇到,那么,如何快速创建100万条测试data呢?我们先创建一张内存表: CREATE TABLE `gu_memory` ( `id` INT (11) NOT NULL AUTO_INCREMENT, `user_id` VARCHAR (20) NOT...
  • 其实我在插入1000万条数据的时候遇到了一些问题,现在先来解决他们,一开始我插入100万条数据时候报错,控制台的信息如下: com.mysql.jdbc.PacketTooBigException: Packet for query is too large (4232009 > ...
  • 插入数据sql代码,java代码转载自----》》https://blog.csdn.net/jason_m_ho/article/details/82941297,本人亲测运行有效 mysql代码,先创建一个testdb数据库在运行下面sql语句创建tb_data表,需要mysql-connector-...
  • 答:在数据里做插入操作的时候,整体时间的分配是这样的: 链接耗时 (30%) 发送query到服务器 (20%) 解析query (20%) 插入操作 (10% * 词条数目) 插入index (10% * Index的数目) 关闭链接 ...
  • 批量插入1000一次,循环调用 可以多线程(批量插入) ...删除100万条数据 执行速度 分范围 100万条数据做分页 limit+索引 回表 通过索引查到主键,在通过主键查到数据,回的过程 ...
  • MySQL插入100w条数据,该怎么做?

    千次阅读 2020-12-06 16:56:36
    那么从sql层面上我们该怎么插入100万条数据呢,无脑直接写个循环?那就使用存储过程试试看吧 DROP PROCEDURE IF EXISTS proc_insert() DELIMITER $ CREATE PROCEDURE pro_insert2() BEGIN DECLARE i INT DEFAULT 1; ...
  • 普通台式机,采集数据,表中已经有>1000万数据量。 采集回来的数据插入表中的时候很慢,每100毫秒。 解决方法: 1、加大mysql配置中的bulk_insert_buffer_size,这个参数默认为8M bulk_insert_buffer_size=100M ...
  • mysql实现快速插入100万条数据

    千次阅读 2019-11-11 14:21:19
    利用mysql内存表插入速度快的特点,先利用函数和存储过程在内存表中生成数据,然后再从内存表插入普通表中 2、创建普通表及内存表 普通表 CREATE TABLE `vote_record` ( `id` INT (11) NOT NULL AUTO_INCREMENT,...
  • 在学习或者工作生产环境中,我们经常要对数据库进行压力测试,往数据库中批量插入大量数据,这里我往Mysql中批量插入大量数据,采用存储过程的方法实现。数据库版本:Mysql5.7一、建表1、创建数据库(student)CREATE ...
  • mysql如何一秒插入10万条数据

    千次阅读 2021-08-28 16:38:28
    当我们需要批量插入或者更新记录时,可以采用Java的批量更新机制,该机制允许多语句甚至一次性提交给数据库处理。通常情况下比一句一提交处理更有效率。...为什么我们需要批量处理sql语句,如果我们提交100万条.
  • 通常来说C++操作MySQL的时候,往Mysql插入10000简单数据,速度非常缓慢,居然要5分钟左右, 而打开事务的话,一秒不到就搞定了! 具体实现代码如下: #include #include #include #include "mysql.h" #...
  • 方法三:该方法采用的是spring batchUpdate执行,因效率问题,数据量只有1万条!执行时间:cast : 387 ms总结:方法一和方法二很类同,唯一不同的是方法一采用的是“insert into tb (...) values(...),(...)...;”的...
  • 有时候在创建数据库之后,有一些已经存在的数据需要插入到数据库,这就涉及到了数据的大规模批量插入了,如果循环使用insert into table values(a,b,c)插入,速度将会比较慢,应该大部分时间都在事务的提交创建上了...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 32,401
精华内容 12,960
关键字:

mysql插入100万条数据

mysql 订阅