关闭

初识Calcite——使用实例

标签: OLAPcalcitejdbc数据访问
8281人阅读 评论(2) 收藏 举报
分类:
      Calcite(https://calcite.apache.org/)是Apache的一个孵化器项目,它是一个构建JDBC或者ODBC访问数据库的框架,通过自定义一些adapter通过sql访问任意类型的数据,回想起我们之前使用SQL的场景只有使用访问关系数据库如MYSQL、ORACLE等,通过hive查询HDFS上的数据,但是如果我们希望通过SQL接口访问内存中的某个数据结构(首先这个结构有关系模型)、文件里面的内容(例如CSV文件、有一定结构的普通文件,其实这些可以通过hive访问)、访问hbase和一些NOSQL数据库,甚至想要跨数据源访问(hive里面的数据和mysql里面的数据进行join查询)。以上基本上代表了我们平时接触到的各种各样的数据存储的位置,而Calcite要解决的问题就是让你想办法将这些数据建立一个关系模型,然后通过SQL查询这些数据。
      假设我们只使用calcite做查询,因为以上的数据基本上都是通过其他方式写入的数据,而我们需要的是通SQL查询,calcite实现了SQL语句的解析,生成物理执行计划以及查询计划的优化,用户需要向Calcite提供数据库的元数据(有哪些database(schema),每一个数据库下有哪些table,每一个表有哪些字段,每一个字段的类型是什么)和数据(每一个表中的每一行数据是什么)。除此之外,用户也可以重载它提供的执行计划,这里只是提及到了Calcite的一些基本功能,高阶功能诸如Streaming(流式查询)、Lattices(物化视图)等,目前使用Calcite的方式是作为一个本地的框架工具而非作为一个服务存在。

Apache Calcite具有以下几个技术特性:

     支持标准SQL语言;
     独立于编程语言和数据源,可以支持不同的前端和后端;
     支持关系代数、可定制的逻辑规划规则和基于成本模型优化的查询引擎;
     支持物化视图(materialized view)的管理(创建、丢弃、持久化和自动识别);
     基于物化视图的Lattice和Tile机制,以应用于OLAP分析;
     支持对流数据的查询。

这里有一篇介绍Calcite的文章可以参考:http://www.infoq.com/cn/articles/new-big-data-hadoop-query-engine-apache-calcite

      下面主要以实践的方式介绍如何使用Calcite查询不同数据源的数据,这里我们的实验的存储是内存中的数据结构,首先我们有一个map:
public static final Map<String, Database> MAP = new HashMap<String, Database>();
       public static class Database {
        public List<Table> tables = new LinkedList<Table>();
    }

   
    public static class Table{
        public String tableName;
        public List<Column> columns = new LinkedList<Column>();
        public List<List<String>> data = new LinkedList<List<String>>();
    }
   
    public static class Column{
        public String name;
        public String type;
    }

      这个MAP中存储了数据库名到我们内存中Database结构的映射,每一个Database中存储了多个Table对象,每一个Table对象有一些Column和一个二维的data数组,Column定义了字段名和类型,然后为了测试创建了一个Database对象,名为school,它包含两个Table,分别为Class和Student,Class对象的初始化如下:
 cl. tableName = "Class";
        Column name = new Column();
        name.name = "name";
        name.type = "varchar";
        cl.columns.add(name);
      
        Column id = new Column();
        id.name = "id";
        id.type = "integer";
        cl.columns.add(id);
       
        Column teacher = new Column();
        teacher.name = "teacher";
        teacher.type = "varchar";
        cl.columns.add(teacher);

Student对象的初始化如下:
        student. tableName = "Student";
        Column name = new Column();
        name.name = "name";
        name.type = "varchar";
        student.columns.add(name);
       
        Column id = new Column();
        id.name = "id";
        id.type = "varchar";
        student.columns.add(id);
       
        Column classId = new Column();
        classId.name = "classId";
        classId.type = "integer";
        student.columns.add(classId);
       
        Column birth = new Column();
        birth.name = "birthday";
        birth.type = "date";
        student.columns.add(birth);
       
        Column home = new Column();
        home.name = "home";
        home.type = "varchar";
        student.columns.add(home);


      接着向这两个表中分别插入一些数据,保存在data成员变量里面,这样,我们的数据就初始化完了,你可以想象这些数据是存储在csv文件中或者redis中,接着就需要和Calcite进行适配,Calcite建立jdbc连接需要一个json文件,这个文件的内容可以通过配置变量传入,也可以通过配置文件读取,文件的格式如下:
{
  version: '1.0',
  defaultSchema: 'school',
  schemas: [
    {
      name: 'school',
      type: 'custom',
      factory: 'org.apache.kylin.calcite.test.MemorySchemaFactory',
      operand: {
        param1: 'hello',
        param2: 'world';
      }
    }
  ]
}


      这里只是一个比较简单的Calcite json model文件,详细的结构可以参考https://calcite.apache.org/docs/model.html,这个文件用于创建connection,所以这里配置的信息是提供给connection使用的,defaultSchema类似于连接mysql时提供database,可以不使用database名就可以访问该数据库的表,schemas定义了一些schema(database的概念),每一个schema指定了name、type(可以分为Map Schema、Custom Schema和JDBC Schema)。
      这三种Schema有不同的使用方式,也决定了下面的参数。使用Map Schema意味着你需要在这个json文件中指定这个schema下的Tables和Functions(具体还需要哪些信息可以参考官方文档),也就是说这个schema是预先定义的(有哪些表,每一个表的结构),所以一般不适用这个(因为大部分情况下需要一些变量才能知道这个这个schema下有哪些表);Custom Schema意味着你只需要指定factory和可选的operand参数(map结构),schema都是通过指定的factory类创建出来的(它需要实现org.apache.calcite.schema.SchemaFactory接口),具体这个schema下面有哪些表可以通过schema的name和operand变量决定生成。JDBC Schema意味着我们可以直接在这个model文件中配置一个jdbc的连接,所有向Calcite的操作其实是由这个数据库完成的,一般也不常用(不如直接通过jdbc连这个数据库了)。
      这里用的是最常用的Custom Schema,所以需要定义一个factory(MemorySchemaFactory),它实现了org.apache.calcite.schema.SchemaFactory接口,需要实现create函数,实现如下:
public class MemorySchemaFactory implements SchemaFactory{
    @Override
    public Schema create(SchemaPlus parentSchema, String name, Map<String, Object> operand) {
        System. out.println( "param1 : " + operand.get( "param1"));
        System. out.println( "param2 : " + operand.get( "param2"));
       
        System. out.println( "Get database " + name);
        return new MemorySchema( name);
    }
}

      这里为了测试打印了一些变量信息,通过测试可以看到name参数传递的是json文件中这个schema的name,operand是文件中这个schema定义的operand。这里要返回一个Schema对象,我们定义了MemorySchema类,需要实现org.apache.calcite.schema.Schema接口,MemorySchema继承了org.apache.calcite.schema.impl.AbstractSchema,后者实现了Schema接口并提供了默认实现,一般情况下我们需要实现下面几个接口:
            public boolean contentsHaveChangedSince( long lastCheck , long now )    这个接口是为了检查cache是否过期,因为calcite默认会缓存schema的元数据,所以可以通过该函数实现cache有效性检查。
            protected Map<String, Table> getTableMap()         这个接口是为了获取schema的元数据,返回值为表名和表对象的映射。
            protected Multimap<String, Function> getFunctionMultimap()       这个接口为了获取该schema支持的UDF函数。

在MemorySchema中我们只实现了getTableMap函数:
@Override
    public Map<String, Table> getTableMap() {
        Map<String, Table> tables = new HashMap<String, Table>();
        Database database = MemoryData. MAP.get( this. dbName);
        if(database == null)
            return tables;
        for(MemoryData.Table table : database. tables) {
            tables.put( table. tableName, new MemoryTable( table));
        }
       
        return tables;
    }


     可以看到,我们只是通过schema名在内存中MAP表里面查看对应的Database对象,然后使用Database对象中的Table作为Schema中的表,表的类型为MemoryTable。
          根据文档中的指示,一般我们可以实现三种类型的Table:
          a simple implementation of Table, using the ScannableTable interface, that enumerates all rows directly;
          a more advanced implementation that implements FilterableTable, and can filter out rows according to simple predicates;
          advanced implementation of Table, using TranslatableTable, that translates to relational operators using planner rules.
      当使用ScannableTable的时候,我们只需要实现函数Enumerable<Object[]> scan(DataContext root);,该函数返回Enumerable对象,通过该对象可以一行行的获取这个Table的全部数据(也就意味着每次的查询都是扫描这个表的数据);当使用FilterableTable的时候,我们需要实现函数Enumerable<Object[]> scan(DataContext root, List<RexNode> filters );参数中多了filters数组,这个数据包含了针对这个表的过滤条件,这样我们根据过滤条件只返回过滤之后的行,减少上层进行其它运算的数据集;当使用TranslatableTable的时候,我们需要实现RelNode toRel( RelOptTable.ToRelContext context, RelOptTable relOptTable);,该函数可以让我们根据上下文自己定义表扫描的物理执行计划,至于为什么不在返回一个Enumerable对象了,因为上面两种其实使用的是默认的执行计划,转换成EnumerableTableAccessRel算子,通过TranslatableTable我们可以实现自定义的算子,以及执行一些其他的rule,Kylin就是使用这个类型的Table实现查询。
      为了简单,我们这里只是使用了ScannableTable,每次做全表扫描。当然除了上面Table需要实现的接口,还需要实现Calcite中最底层Table定义的接口,当然有AbstractTable实现了一些默认的方案,我们只需要实现获取表中元数据的函数getRowType和获取数据的函数scan。 
@Override
    public RelDataType getRowType(RelDataTypeFactory typeFactory) {
        if(dataType == null) {
            RelDataTypeFactory.FieldInfoBuilder fieldInfo = typeFactory.builder();
            for (MemoryData.Column column : this. sourceTable. columns) {
                RelDataType sqlType = typeFactory.createSqlType(
                        MemoryData.SQLTYPE_MAPPING.get(column .type ));
                sqlType = SqlTypeUtil.addCharsetAndCollation(sqlType, typeFactory);
                fieldInfo.add( column. name, sqlType);
            }
            this. dataType = typeFactory.createStructType( fieldInfo);
        }
        return this.dataType;
    }
   
    @Override
    public Enumerable<Object[]> scan(DataContext root) {
        final int[] fields = identityList(this.dataType.getFieldCount());
        return new AbstractEnumerable<Object[]>() {
            public Enumerator<Object[]> enumerator() {
                return new MemoryEnumerator<Object[]>( fields, sourceTable. data);
            }
        };
    }


      表中的元数据(字段名和字段类型)是根据初始化数据中Table中每一个Column的类型转换的,MemoryData.SQLTYPE_MAPPING提供了自定义类型到Calcite类型的映射。scan函数返回一个迭代器对象,通过调用该对象的moveNext函数可以获取是否已经遍历完全部的数据,current函数返回当前的一行数据,还可以根据需要实现一些其他的函数,这里不再一一介绍了。

      好了,整体的实现就是这个样子的,对于一个查询操作会经历如下的流程:Calcite会解析SQL并将其转换成逻辑执行计划,期间会根据当前connection中schema定义的信息初始化每一个Schema,然后根据查询中指定的schema调用对应的getTableMap函数获取元数据,根据这个信息判断查询中出现的表名、字段名是否正确以及检查SQL语法是否符合规范。然后再使用Calcite内部默认的实现生成物理执行计划,这个查询计划是树状结构的,最底层的节点是ScanTable操作(类似于SQL执行过程中首先执行FROM子句),对每一个表获取该表的数据,这时候使用的算子为默认的EnumerableTableAccessRel,然后再去调用具体ScannableTable的scan方法获取表的数据。完了之后在根据原始表的数据进行上层的JOIN、FILTER、GROUP BY、SORT、LIMIT甚至子查询等操作。

测试代码:
public static void main(String[] args) {
     try {
                Class. forName("org.apache.calcite.jdbc.Driver");
           } catch (ClassNotFoundException e1) {
                 e1.printStackTrace();
           }
     
        Properties info = new Properties();
        try {
            Connection connection =
                DriverManager.getConnection("jdbc:calcite:model=E:\\file\\to\\model\\file\\School.json", info );
            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 \"home\", 1 , count(1) from \"Student\" as S INNER JOIN \"Class\" as C on S.\"classId\" = C.\"id\" group by \"home\"");
            while( result.next()) {
                System. out.println( result.getString(1) + "\t" + result.getString(2) + "\t" + result.getString(3));
            }
            result.close();
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }



执行结果:
param1 : hello
param2 : world
Get database school
Catalog : null,Database : metadata,Table : COLUMNS
Catalog : null,Database : metadata,Table : TABLES
Catalog : null,Database : school,Table : Class
Catalog : null,Database : school,Table : Student
sichuan       1      1
zhejiang      1      1
henan  1      1
jiangsu       1      1
hebei  1      1
beijing       1      1
anhui  1      2

      其中前面三行为Calcite创建Schema的时候打印的,下面四行为当前connection中的表,前两个表为系统表,后面两个表是我们自定义的表,接下来执行一次带有JOIN的SQL查询,能够输出正确的结果。需要注意的是,Calcite中元数据类似于Oracle的,所有的表和字段名都会在解析的时候转换成大写,但是在Calcite中又是大小写敏感的,因此除非你将所有的表名和字段名都定义成大写,获取在查询的时候对于字段和表都加上双引号(这样在解析的时候就不会被转换成大写了),否则很可能出现字段或者表找不到的错误(http://stackoverflow.com/questions/31118348/table-not-found-with-apache-calcite)。

源码下载地址:https://github.com/terry-chelsea/bigdata,会持续更新一些自己在大数据生态圈学习和开发过程中用到的代码。欢迎交流...

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:193717次
    • 积分:2544
    • 等级:
    • 排名:第14423名
    • 原创:70篇
    • 转载:7篇
    • 译文:0篇
    • 评论:104条
    最新评论