首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >我也能写数据库 —— 单表查询

我也能写数据库 —— 单表查询

作者头像
麒思妙想
发布2020-07-10 13:36:37
6220
发布2020-07-10 13:36:37
举报
文章被收录于专栏:麒思妙想麒思妙想

前言

说不定期更新,就不定期更新:)。

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

这里我们的目标是:

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

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",自定义类型,其他还包括tableview等 接下来"factory": "com.dafei1288.calcite.InMemorySchemaFactory"相当于定义我们程序的入口,如何加载一个schema

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

InMemorySchemaFactory

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

public class InMemorySchemaFactory implements SchemaFactory {
   @Override
   public 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);   }
   @Override
   public 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;
   }   @Override
   public 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;
   }   @Override
   public 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;
                   @Override
                   public 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++);
                   }                   @Override
                   public boolean moveNext() {
//                        System.out.println("++cur < _table.getRowCount() = "+(cur+1 < _table.getRowCount()));
                       return cur < _table.getRowCount() ;
                   }                   @Override
                   public void reset() {                   }                   @Override
                   public 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这个方法相对复杂一点,提供了全表扫面的功能,这里主要需要高速引擎,如何遍历及获取数据。其结构还是比较复杂得,为了减少本例中类的个数,避免复杂得代码结构,吓跑初学者,所以,采用了内部类嵌套的形式,含义还是比较明确的。 主要就是实现currentmoveNext方法。这里还是由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>>里,各类都提供基础的gettersetter方法,数据初始化则写在静态块里。

测试

写个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:\\working\\others\\写作\\calcitetutorial\\src\\main\\resources\\bookshop.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();
       }
   }

技术总结

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

后记

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

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

本文参与 腾讯云自媒体分享计划,分享自微信公众号。
原始发表:2018-12-11,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 麒思妙想 微信公众号,前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体分享计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 前言
  • model.json
  • InMemorySchemaFactory
  • InMemorySchema
  • InMemoryTable
  • Storage
  • 测试
  • 技术总结
  • 后记
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档