数据库单表数据过亿_我也能写数据库 —

前言

说不定期更新，就不定期更新：)。

在翻译关系代数这篇文档的时候，总有一种惴惴不安的感觉伴随着我，其实还是对之前概览的一知半解，而DEMO项目Calcite-example-CSV为了介绍特性，添加了太多代码进来，这虽然很好，因为当你执行代码的时候，就能看到所有特性，但是对于一个新手来讲却未必够友好，我也是这样的一个新手，看着文档里不知所云的概念和代码片段，经常会有挫败感。那不如我们就来实实在在的完成一个Helloworld来查询一个表（当然这个表示我们自己定义的格式）就这么简单。来体会一下Calcite的魅力吧。

这里我们的目标是：

数据在一个自己可控的位置，本文写在一个Java文件的静态块里
可以执行一个简单查询并返回数据

model.json

我习惯gradle，所以起手构建一个空白gradle项目，添加依赖：

compile group: 'org.apache.calcite', name: 'calcite-core', version: '1.17.0'

在resources下构建一个bookshop.json：

{"version": "1.0","defaultSchema": "bookshop","schemas": [{"type": "custom","name": "bookshop","factory": "com.dafei1288.calcite.InMemorySchemaFactory","operand": {"p1": "hello","p2": "world"}}]
}

首先给库定义一个名字："defaultSchema": "bookshop" 然后描述类型"type": "custom"，自定义类型，其他还包括table，view等接下来"factory": "com.dafei1288.calcite.InMemorySchemaFactory"相当于定义我们程序的入口，如何加载一个schema

在构想初期只是想实现一个简单的bookshop数据库，后面在Storage介绍里，也会提到，我设计了2张表，book和author。

InMemorySchemaFactory

首先让我们来看一下代码：

public class InMemorySchemaFactory implements SchemaFactory {@Overridepublic Schema create(SchemaPlus parentSchema, String name, Map<String, Object> operand) {System.out.println("schema name ==>  "+ name);System.out.println("operand ==> "+operand);return new InMemorySchema(name,operand);}
}

因为在bookshop.json里定义了属性"factory": "com.dafei1288.calcite.InMemorySchemaFactory"，所以InMemorySchemaFactory被默认加载，该类需要继承SchemaFactory,重写create方法的时候，可以根据自己需要来构建逻辑，这里我们只打印了几个参数看一眼，就略过，实例化一个InMemorySchema。

InMemorySchema

我们还是先把代码贴上：

public class InMemorySchema extends AbstractSchema {private String dbName;private Map<String, Object> operand;public InMemorySchema(String name, Map<String, Object> operand) {this.operand = operand;this.dbName = dbName;System.out.println("");System.out.println("in this class ==> "+ this);}@Overridepublic Map<String, Table> getTableMap() {Map<String, Table> tables = new HashMap<String, Table>();Storage.getTables().forEach(it->{//System.out.println("it = "+it.getName());tables.put(it.getName(),new InMemoryTable(it. getName(),it));});return tables;}
}

InMemorySchema类也是相当简单的，首先继承AbstractSchema,实际上需要复写的getTableMap就是这个方法，它的职责就是要提供一个表名和表的映射表，为了实现这个，我们需要做一些处理，当然本例里是使用了一个Storage类，来模拟存储表结构信息，以及数据的，这里的表结构以及其他信息都不需要外接再提供额外辅助，如果是使用其他类型的，就可能需要根据自己的实际需求，扩展operand属性，来携带必要参数进来了。

Storage直接提供了getTables方法，可以直接从里面获取到当前存在的表，这样直接将Storage内的表转化成InMemoryTable类就可以了。

InMemoryTable

还是先从代码入手：

public class InMemoryTable extends AbstractTable implements ScannableTable {private String name;private Storage.DummyTable _table;private RelDataType dataType;InMemoryTable(String name){System.out.println("InMemoryTable !!!!!!    "+name );this.name = name;}public InMemoryTable(String name, Storage.DummyTable it) {this.name = name;this._table = it;}@Overridepublic RelDataType getRowType(RelDataTypeFactory typeFactory) {
//        System.out.println("RelDataType !!!!!!");if(dataType == null) {RelDataTypeFactory.FieldInfoBuilder fieldInfo = typeFactory.builder();for (Storage.DummyColumn column : this._table.getColumns()) {RelDataType sqlType = typeFactory.createJavaType(String.class);sqlType = SqlTypeUtil.addCharsetAndCollation(sqlType, typeFactory);
//                System.out.println(column.getName()+" / "+sqlType);fieldInfo.add(column.getName(), sqlType);}this.dataType = typeFactory.createStructType(fieldInfo);}return this.dataType;}@Overridepublic Enumerable<Object[]> scan(DataContext root) {System.out.println("scan ...... ");return new AbstractEnumerable<Object[]>() {public Enumerator<Object[]> enumerator() {return new Enumerator<Object[]>(){private int cur = 0;@Overridepublic Object[] current() {
//                        System.out.println("cur = "+cur+" => ");
//                        for (int i =0;i<_table.getData(cur).length;i++){
//                            System.out.println(_table.getData(cur)[i]);
//                        }return _table.getData(cur++);}@Overridepublic boolean moveNext() {
//                        System.out.println("++cur < _table.getRowCount() = "+(cur+1 < _table.getRowCount()));return cur < _table.getRowCount() ;}@Overridepublic void reset() {}@Overridepublic void close() {}};}};}
}

这里我保留了很多难看的System.out,其实也是为了展示一下我走过的弯路，在这里面，遇到奇奇怪怪的坑，由于Calcite的结构原因，有时出错从日志上很难发现原因，或者说很难准确断定原因，当然也许是笔者水平所限的缘故。 InMemoryTable需要继承AbstractTable实现ScannableTable的接口，在这里Calcite提供了几种Table接口，待日后分解。这个类里，我们主要需要处理的2个方法public RelDataType getRowType(RelDataTypeFactory typeFactory)和public Enumerable<Object[]> scan(DataContext root).

getRowType用来处理列的类型的，不要被那几句代码所迷惑，为了顺利运行，并没有针对数据的类型做什么处理，而是简单粗暴了使用了String，有兴趣的话，可以根据自己的实际情况来注册，日后有机会会详细介绍这部分。 scan这个方法相对复杂一点，提供了全表扫面的功能，这里主要需要高速引擎，如何遍历及获取数据。其结构还是比较复杂得，为了减少本例中类的个数，避免复杂得代码结构，吓跑初学者，所以，采用了内部类嵌套的形式，含义还是比较明确的。主要就是实现current和moveNext方法。这里还是由Storage提供了数据的存储功能，所以只需要遍历，获取一下数据而已，其他方法暂时不管。

写到这，其实和Calcite相关的代码已经完成了，整个工程的主体代码也完成了，现在只需要再介绍一下Storage

Storage

/*** 用于模拟数据库结构及数据** author : id,name,age* book : id,aid,name,type* */
public class Storage {public static final String SCHEMA_NAME = "bookshop";public static final String TABLE_AUTHOR = "AUTHOR";public static final String TABLE_BOOK = "BOOK";//    public static List<DummyTable> tables = new ArrayList<>();public static Hashtable<String,DummyTable> _bag = new Hashtable<>();static{DummyTable author = new DummyTable(TABLE_AUTHOR);DummyColumn id = new DummyColumn("ID","String");DummyColumn name = new DummyColumn("NAME","String");DummyColumn age = new DummyColumn("AGE","String");DummyColumn aid = new DummyColumn("AID","String");DummyColumn type = new DummyColumn("TYPE","String");author.addColumn(id).addColumn(name).addColumn(age);author.addRow("1","jacky","33");author.addRow("2","wang","23");author.addRow("3","dd","32");author.addRow("4","ma","42");
//        tables.add(author);_bag.put(TABLE_AUTHOR,author);DummyTable book = new DummyTable(TABLE_BOOK);book.addColumn(id).addColumn(name).addColumn(aid).addColumn(type);book.addRow("1","1","数据山","java");book.addRow("2","2","大关","sql");book.addRow("3","1","lili","sql");book.addRow("4","3","ten","c#");
//        tables.add(book);_bag.put(TABLE_BOOK,book);}public static Collection<DummyTable> getTables(){return _bag.values();}public static DummyTable getTable(String tableName){return _bag.get(tableName);}public static class DummyTable{private String name;private List<DummyColumn> columns;private List<List<Object>> datas = new ArrayList<>();DummyTable(String name){this.name = name;}public String getName(){return this.name;}public List<DummyColumn> getColumns() {return columns;}public DummyTable addColumn(DummyColumn dc){if(this.columns == null){this.columns = new ArrayList<>();}this.columns.add(dc);return this;}public void setColumns(List<DummyColumn> columns) {this.columns = columns;}public Object[] getData(int index){return this.datas.get(index).toArray();}public int getRowCount(){return this.datas.size();}public void addRow(Object...objects){this.datas.add(Arrays.asList(objects));}}public static class DummyColumn{private String name;private String type;public DummyColumn(String name, String type) {this.name = name;this.type = type;}public String getName() {return name;}public String getType() {return type;}public void setName(String name) {this.name = name;}public void setType(String type) {this.type = type;}}}

这里我们用了一个简单的结构来模拟了存储，Storage下面包含DummyTable,DummyTable包含DummyColumn,用于存放元数据信息，而数据则包含在一个List<List<Object>>里，各类都提供基础的getter和setter方法，数据初始化则写在静态块里。

测试

写个main方法测试一下：

public static void main(String[] args) {try {Class.forName("org.apache.calcite.jdbc.Driver");} catch (ClassNotFoundException e1) {e1.printStackTrace();}Properties info = new Properties();String jsonmodle = "E:workingothers写作calcitetutorialsrcmainresourcesbookshop.json";try {Connection connection =DriverManager.getConnection("jdbc:calcite:model="+jsonmodle, info);CalciteConnection calciteConn = connection.unwrap(CalciteConnection.class);ResultSet result = connection.getMetaData().getTables(null, null, null, null);while(result.next()) {System.out.println("Catalog : " + result.getString(1) + ",Database : " + result.getString(2) + ",Table : " + result.getString(3));}result.close();Statement st = connection.createStatement();result = st.executeQuery("select * from book as b");while(result.next()) {System.out.println(result.getString(1) + "t" + result.getString(2) + "t" + result.getString(3));}result.close();//connection.close();st = connection.createStatement();result = st.executeQuery("select a.name from author as a");while(result.next()) {System.out.println(result.getString(1));}result.close();connection.close();}catch(Exception e){e.printStackTrace();}}

技术总结

Calcite能提供一个透明的JDBC实现，使用者可以按自己的方式规划存储，这个特性在数据分析中，其实更适合，比如在多源、跨源联合查询上，威力巨大。
按接口实现相关schema和table，目前只实现了流程上跑通，单不代表他们就是这样，在这里我们还有很长的路要走
自定义视图配上model上配置的参数，也许可以作为数据权限一种实现

后记

上述项目代码库传送门：https://github.com/dafei1288/CalciteHelloworld.git

目前只提供了全表扫面，条件判断表连接都还不行，待日后更新。而Calcite强大的优化工作还没登场呢。