SparkSql学习1 —— 借助SQlite数据库分析2000万数据

总所周知，Spark在内存计算领域非常强势，是未来计算的方向。Spark支持类Sql的语法，方便我们对DataFrame的数据进行统计操作。

但是，作为初学者，我们今天暂且不讨论Spark的用法。我给自己提出了一个有意思的思维游戏：Java里面的随机数算法真的是随机的吗？

好，思路如下：

1. 取样，利用Java代码随机生成2000万条0-1000的整数（包括0，但是不包括1000）

2. 分析每个整数的出现次数。

如果出现次数分布非常均匀，那么可以证明随机数算法还是比较靠谱的。

那么，现在就动手：

第一步：编写java代码往数据库里面造数据

这里我选择的是sqlite数据库的内存模式，之所以这样选择，是因为文件型数据库的内存模式可以节省网络开销，小巧精悍：

java代码：

1package com.lnwazg.dbkit.controller;
2
3import java.sql.SQLException;
4import java.util.ArrayList;
5import java.util.List;
6
7import org.apache.commons.lang3.RandomUtils;
8
9import com.lnwazg.dbkit.dao.SqliteDao;
10import com.lnwazg.dbkit.jdbc.MyJdbc;
11import com.lnwazg.dbkit.proxy.MyDaoProxy;
12import com.lnwazg.dbkit.utils.DbKit;
13import com.lnwazg.dbkit.vo.Record;
14import com.lnwazg.kit.testframework.TF;
15import com.lnwazg.kit.testframework.anno.AfterFinalOnce;
16import com.lnwazg.kit.testframework.anno.PrepareStartOnce;
17import com.lnwazg.kit.testframework.anno.TestCase;
18
19/**
20 * 随机插入2000万条随机数
21 * @author nan.li
22 * @version 2016年6月2日
23 */
24public class SqliteTest2
25{
26    MyJdbc jdbc = null;
27    
28    SqliteDao sqliteDao = null;
29    
30    @PrepareStartOnce
31    void prepareStartOnce()
32    {
33        //初始化jdbc连接
34        jdbc = DbKit.getJdbc("sqlite3.properties");
35        sqliteDao = MyDaoProxy.proxyDaoInterface(SqliteDao.class, jdbc);//根据接口生成动态代理类
36    }
37    
38    @AfterFinalOnce
39    void afterFinalOnce()
40    {
41    }
42    
43    @TestCase
44    void doTest()
45        throws SQLException
46    {
47        //插入2000万条数据，然后用sql计算出分布情况
48        //        每次10000条记录，循环2000次
49        sqliteDao.createTable(Record.class);
50        for (int i = 0; i < 200; i++)
51        {
52            List<Record> list = new ArrayList<>();
53            for (int j = 0; j < 100000; j++)
54            {
55                list.add(new Record().setNumber(RandomUtils.nextInt(0, 1000)));//随机数，值为0-999
56            }
57            sqliteDao.insertBatch(list, 50000);//批量插入，batchSize设置为50000
58            System.out.println(String.format("第%s次插入成功！", i + 1));
59        }
60    }
61    
62    public static void main(String[] args)
63    {
64        TF.l(SqliteTest2.class);
65    }
66}

数据库配置：

1url=jdbc:sqlite://d:/largeData.db
2username=
3password=

Record类结构：

1package com.lnwazg.dbkit.vo;
2
3import org.apache.commons.lang3.builder.ToStringBuilder;
4import org.apache.commons.lang3.builder.ToStringStyle;
5
6import com.lnwazg.dbkit.anno.AutoIncrement;
7import com.lnwazg.dbkit.anno.Id;
8
9public class Record
10{
11    @Id
12    @AutoIncrement
13    private Integer id;
14    
15    private Integer number;
16    
17    public Integer getId()
18    {
19        return id;
20    }
21    
22    public Record setId(Integer id)
23    {
24        this.id = id;
25        return this;
26    }
27    
28    public Integer getNumber()
29    {
30        return number;
31    }
32    
33    public Record setNumber(Integer number)
34    {
35        this.number = number;
36        return this;
37    }
38    
39    @Override
40    public String toString()
41    {
42        return ToStringBuilder.reflectionToString(this, ToStringStyle.JSON_STYLE);
43    }
44    
45}

好了，代码跑起来，每插入10w条数据需要消耗37秒钟，每秒钟插入成功2702条数据，这个效率我还是比较满意的。

大约等了2个钟头，全部数据就造好了，占用230MB大小。

第二步：开始分析

表结构以及数据如下：

先验证一下记录数对不对：

OK，2000万条数据，如假包换。

好了，开始分组分析：

可以看到，最小的随机数是0，最大的随机数是999。 所有的随机数的出现次数都趋近于20000次，分布情况相当均匀，最大误差不超过450。

这个数字，跟我们期待的值是一致的：  20000000条记录 / 1000种数字 = 20000条记录/种数字。

由此可以证明，java里面的随机数算法还是相当可靠的。