greenplum 导入 Spark计算的RoaringBitmap

最近在做基于标签的圈人。通过bitmap来做，使用开源的RoaringBitmap，数据存储在hive上。
开始是通过greenplum的pxf插件，将数据导入到gp，然后聚合标签生成Roaringbitmap。
但是这样的方式效率低，于是在spark中构建，然后将构建好的bitmap导入gp中。
开始使用udaf的方式这样计算效率较低

import org.apache.spark.sql.Row;
import org.apache.spark.sql.expressions.MutableAggregationBuffer;
import org.apache.spark.sql.expressions.UserDefinedAggregateFunction;
import org.apache.spark.sql.types.DataType;
import org.apache.spark.sql.types.DataTypes;
import org.apache.spark.sql.types.StructField;
import org.apache.spark.sql.types.StructType;
import org.roaringbitmap.RoaringBitmap;
 
import java.io.*;
import java.util.ArrayList;
import java.util.List;
 
/**
 * 实现自定义聚合函数Bitmap
 */
public class UdafBitMap extends UserDefinedAggregateFunction {
    @Override
    public StructType inputSchema() {
        List<StructField> structFields = new ArrayList<>();
        structFields.add(DataTypes.createStructField("field", DataTypes.BinaryType, true));
        return DataTypes.createStructType(structFields);
    }
 
    @Override
    public StructType bufferSchema() {
        List<StructField> structFields = new ArrayList<>();
        structFields.add(DataTypes.createStructField("field", DataTypes.BinaryType, true));
        return DataTypes.createStructType(structFields);
    }
 
    @Override
    public DataType dataType() {
        return DataTypes.LongType;
    }
 
    @Override
    public boolean deterministic() {
        //是否强制每次执行的结果相同
        return false;
    }
 
    @Override
    public void initialize(MutableAggregationBuffer buffer) {
        //初始化
        buffer.update(0, null);
    }
 
    @Override
    public void update(MutableAggregationBuffer buffer, Row input) {
        // 相同的executor间的数据合并
        // 1. 输入为空直接返回不更新
        Object in = input.get(0);
        if(in == null){
            return ;
        }
        // 2. 源为空则直接更新值为输入
        byte[] inBytes = (byte[]) in;
        Object out = buffer.get(0);
        if(out == null){
            buffer.update(0, inBytes);
            return ;
        }
        // 3. 源和输入都不为空使用bitmap去重合并
        byte[] outBytes = (byte[]) out;
        byte[] result = outBytes;
        RoaringBitmap outRR = new RoaringBitmap();
        RoaringBitmap inRR = new RoaringBitmap();
        try {
            outRR.deserialize(new DataInputStream(new ByteArrayInputStream(outBytes)));
            inRR.deserialize(new DataInputStream(new ByteArrayInputStream(inBytes)));
            outRR.or(inRR);
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            outRR.serialize(new DataOutputStream(bos));
            result = bos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        }
        buffer.update(0, result);
    }
 
    @Override
    public void merge(MutableAggregationBuffer buffer1, Row buffer2) {
        //不同excutor间的数据合并
        update(buffer1, buffer2);
    }
 
    @Override
    public Object evaluate(Row buffer) {
        //根据Buffer计算结果
        long r = 0l;
        Object val = buffer.get(0);
        if (val != null) {
            RoaringBitmap rr = new RoaringBitmap();
            try {
                rr.deserialize(new DataInputStream(new ByteArrayInputStream((byte[]) val)));
                r = rr.getLongCardinality();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return r;
    }
}

因为RoaringBitmap是复杂的类，不能直接存储gp，需要序列化成 bytea 类型。
基本思路是每个分区的数据构建一个bitmap，然后序列化到hdfs上，通过pxf
插件，建立外表的方式将数据导入gp
1.gp中建表dim_{colName}_tag(id int,userids bytea)。此处是bytea类型。
2.在spark中建立roaringbitmap。每个分区的数据生成一个bitmap，然后序列化。这里使用scala写的

 mp.foreach(m => {
        val v = m._1
        val d = m._2
        println(s"current tag ${d} col_value ${v}")
        val colsql = s"select ${d},row_id from mytable where ${col} = ${v}"
        val coldf = spark.sql(colsql)

        val res = coldf.mapPartitions(each => {
          val mrb = new RoaringBitmap()
          each.map(_.getLong(1).toInt).toList.foreach(mrb.add(_))
          mrb.runOptimize()
          val array = new Array[Byte](mrb.serializedSizeInBytes)
          mrb.serialize(new DataOutputStream(new OutputStream() {
            var c = 0
            override
            def close(): Unit = {
            }
            override
            def flush(): Unit = {
            }
            override
            def write(b: Int): Unit = {
              array({
                c += 1;
                c - 1
              }) = b.toByte
            }
            override
            def write(b: Array[Byte]): Unit = {
              write(b, 0, b.length)
            }
            override
            def write(b: Array[Byte], off: Int, l: Int): Unit = {
              System.arraycopy(b, off, array, c, l)
              c += l
            }
          }))
          Iterator((d, array))
        })

3.spark数据写到保存到hdfs，可以采用parquet格式。
4.在gp中建立外表。使用pxf插件。

CREATE EXTERNAL TABLE dim_${colName}_$tag(tag int,row_id bytea) LOCATION ('pxf:/$RELATE_ROW_PATH/pt=$pt/$tag?PROFILE=hdfs:parquet') FORMAT 'CUSTOM' (FORMATTER='pxfwritable_import');"

这里外表与hdfs的目录对应。这样可以导入数据到gp中。
5.最重要的一步，就是将序列化的RoaringBitmap反序列化生成roaringbitmap。
建立tagtable(id int,userids roaringbitmap)。需要提前安装roaringbitmap插件。

"INSERT INTO btable SELECT tag, rb_or_agg(cast(cast(row_id as varchar) as roaringbitmap)), current_timestamp from dim_${colName}_$tag group by tag;"

最核心的部分是

cast(row_id as varchar) 二进制数据转成字符
cast(cast(row_id as varchar) as roaringbitmap 字符转成roaringbitmap。
目前，只找到了这重点方法。虽然官网提供了spark-gp的connector，但是没有测试成功将bytea数据直接写入gp。
只能中间导入的方式。