通过clickhouse源码了解hive/spark的RoaringBitmap写入Clickhouse的bitmap
先说结论：要把hive上的bitmap数据同步到clickhouse的bitmap里面
参考连接：
https://blog.csdn.net/nazeniwaresakini/article/details/108166089
https://blog.csdn.net/qq_27639777/article/details/111005838
https://zhuanlan.zhihu.com/p/351365841
https://blog.csdn.net/yizishou/article/details/78342499
https://github.com/RoaringBitmap/CRoaring
1、Clickhouse的RoaringBitmap结构
目标是将Hive的Binary类型能顺利转成Clickhouse的Bitmap类型
Hive的Binary类型是二进制数组byte[]
Clickhouse的Bitmap类型是,一般是通过groupBitmap方式构建出来的，比如：
select series_id, groupBitmapState(toUInt32(dvid)) bitmap列 FROM dms_pds_flow_interest_dvid_city_day_all group by series_id
其中关键sql是：groupBitmapState，源码对应位置是：AggregateFunctionGroupBitmap.cpp注册的;
这个C++代码的关键点是：
createAggregateFunctionBitmap<AggregateFunctionGroupBitmapData>
代表通过函数：createAggregateFunctionBitmap来创建bitmap类型：AggregateFunctionGroupBitmapData
然后跟进这个AggregateFunctionGroupBitmapData类,文件（AggregateFunctionGroupBitmapData.h）
结构：
内部：
其中bitmap的一些计算函数逻辑，就是这个AggregateFunctionGroupBitmapData.h文件实现的；比如：
select bitmapOrCardinality(bitmap_a , bitmap_b) 是取两个bitmap的并集；
那么实现就是：
言归正传,根据Rbitmap的数据结构：
参考连接：https://zhuanlan.zhihu.com/p/351365841
1、首先，将 32bit int（无符号的）类型数据 划分为 2^16 个桶（即使用数据的前16位二进制作为桶的编号）， 每个桶有一个Container（可以理解为容器也可以理解为这个桶，容器和桶在这里可以理解为一个东西，只是说法不一样而已） 来存放一个数值的低16位。 2、在存储和查询数值时，将数值 k 划分为高 16 位和低 16 位，取高 16 位值找到对应的桶， 然后在将低 16 位值存放在相应的 Container 中。这样说可能比较抽象不易理解，下面以一个例子来帮助大家理解。
大概意思是，在clickhouse的Rbitmap里面，为了优化存储空间，会将一个32位的数据，分成高16位和低16位;
高16位会被作为key存储到short[] keys中，低16位则被看做value
比如我要存储666这个数字，需要将666划分成高16位和低16位,通过高16位定位到当前桶是5，定位到竖着排列的桶未知后，在将低16位的值存储到横着排列的数组中;
之前看clickhouse源码中C++里面返回的roaring和roaring64map到底是啥,在看CRoaring源码，创建Rbitmap的地方：
其中的关键点是：
上面意思是定义一个结构体，类型是roaring_array_t , 变量名是：high_low_container
这个就是图片里面说的高16位和低16位的存储模型，然后查看roaring_array_t的结构：
然后查看ROARING_CONTAINER_T,也就是低16位类型是,因为clickhouse是C++编写的，因此构建的数组其实是：struct container_s {}指向的各个子类
返回Clickhouse的源码,要开辟的子类就是：
这样就又回到了Clickhouse的Rbitmap。虽然转了一圈，但是已经知道这个Rbitmap底层存储的其实是数组
2、hive或者sparksql里面的RoaringBitmap
参考hive制作bitmap的连接：https://github.com/sunyaf/bitmapudf
关键就是了解UDAF里面的函数：
// 输入输出都是Object inspectors public ObjectInspector init(Mode m, ObjectInspector[] parameters) throws HiveException; // AggregationBuffer保存数据处理的临时结果 abstract AggregationBuffer getNewAggregationBuffer() throws HiveException; // 重新设置AggregationBuffer public void reset(AggregationBuffer agg) throws HiveException; // 处理输入记录 public void iterate(AggregationBuffer agg, Object[] parameters) throws HiveException; // 处理全部输出数据中的部分数据 public Object terminatePartial(AggregationBuffer agg) throws HiveException; // 把两个部分数据聚合起来 public void merge(AggregationBuffer agg, Object partial) throws HiveException; // 输出最终结果 public Object terminate(AggregationBuffer agg) throws HiveException;
我们要兼容hive的Rbitmap和Clickhouse的Rbitmap，只需要关键方法：terminate到底返回了什么
查看代码：
所以关键代码就是：myagg.getPartial()
hive里面返回的Rbitmap其实最终是java的二进制数组;
所以要想Hive的Rbitmap和Clickhouse的Rbitmap能够兼容，就是演变成：Hive的二进制数组如何有效的存储到Clickhouse里面
3、Clickhouse的Roaringbitmap是如何存储的
在回看Clickhouse的Rbitmap，比如看添加像Rbitmap里面添加内容。它的api是：
RoaringBitmap.add(1);
RoaringBitmap.add(2);
其源码是：
//如果基数超过32个，则会将数据存储到Rbitmap void toLarge() { //通过智能指针建立对象 rb = std::make_shared<RoaringBitmap>(); //C++ 里面的for循环，翻译成java就是：for (A x:small) for (const auto & x : small) //将smallSet的数据存储到Rbitmap里面 rb->add(static_cast<Value>(x.getValue())); //清空smallSet small.clear(); }
void add(T value) { //判断存储个数是否小于32 if (isSmall()) { if (small.find(value) == small.end()) { //如果插入的元素没有超过smallSet的容量，则添加到smallSet if (!small.full()) small.insert(value); //如果插入的元素个数超过了smallSet容量，则插入RoaringBitmap else { toLarge(); rb->add(static_cast<Value>(value)); } } } //如果超过32则按照 else { rb->add(static_cast<Value>(value)); } }
其中内部的写入是：
void write(DB::WriteBuffer & out) const { //判断基数，是否超过32来判断底层的存储 UInt8 kind = isLarge() ? BitmapKind::Bitmap : BitmapKind::Small; //写入一个UInt8的标识到buf中，0代表使用smallset 1代表使用RoaringBitmap writeBinary(kind, out); //smallSet的写入 if (BitmapKind::Small == kind) { small.write(out); } //Rbitmap的写入 else if (BitmapKind::Bitmap == kind) { //得到要写入内存的Rbitmap字节大小 auto size = rb->getSizeInBytes(); writeVarUInt(size, out);
//通过指针占有并管理另一对象 std::unique_ptr<char[]> buf(new char[size]); rb->write(buf.get()); out.write(buf.get(), size); } }
其中getSizeInBytes() 这个方法要去CRoaring里面找：
/** * How many bytes are required to serialize this bitmap (meant to be * compatible with Java and Go versions) * * Setting the portable flag to false enable a custom format that * can save space compared to the portable format (e.g., for very * sparse bitmaps). */ size_t getSizeInBytes(bool portable = true) const { if (portable) return api::roaring_bitmap_portable_size_in_bytes(&roaring); else return api::roaring_bitmap_size_in_bytes(&roaring); }
追下去的大概意思就是：
一个header头部大小
一个Ritmao里面Container数组存储元素个数
然后header ++ Container数组元素的字节大小
writeVarInt(size , out)的参考连接：https://blog.csdn.net/B_e_a_u_tiful1205/article/details/106064778
所以要写入Rbitmap，需要存储结构是：
1、writeBinary(1, out) : java中的Byte(1) 2、 auto size = rb->getSizeInBytes(); writeVarUInt(size, out); 就是像buffer中写入需要序列化的的字节大小 3、将RoaringBitmap转化成字节数组
参考一位大神的的，对应java结果就是：https://blog.csdn.net/qq_27639777/article/details/111005838
Byte(1), VarInt(SerializedSizeInBytes), ByteArray(RoaringBitmap)
4、将java的Rbitmap转成Clickhouse的Rbitmap
在clickhouse中构建一个bitmap：
select bitmapToArray(bitmapBuild([toUInt32(3), toUInt32(4), toUInt32(100)]));
然后对bitmap做一个编码：
SELECT base64Encode(toString(bitmapBuild([toUInt32(3), toUInt32(4), toUInt32(100)])));
在反过来,将编码转回bitmap
1、构建表：
CREATE TABLE test_index.spark_bitmap_test( dt LowCardinality(String) COMMENT '日期', dim_type Int32 COMMENT '维度类型', dim_id Int32 COMMENT '纬度值', encode String COMMENT '编码', compare_encode AggregateFunction(groupBitmap, UInt32) MATERIALIZED base64Decode(encode) ) Engine = AggregatingMergeTree() PARTITION BY toYYYYMMDD(toDate(dt)) PRIMARY KEY (dim_type, dim_id) ORDER BY (dim_type, dim_id) SETTINGS index_granularity = 4;
2、将编码插入到bitmap
insert into test_index.spark_bitmap_test values ('2021-12-14' , 1 , 2370 , 'AAMDAAAABAAAAGQAAAA=');
3、查询：
select dt , dim_type , dim_id , encode , bitmapToArray(compare_encode) as arr , bitmapCardinality(compare_encode) as encode from test_index.spark_bitmap_test;
以上操作就是为了证明，如果在java中能够将bitmap进行编码，这样通过clickhouse的物化视图自动将编码字符串转成bitmap
结合之前分析的源码：
1、小于32的用smallSet存储 1）：Byte(0) 2）：Buffer(RoaringBitmap需要序列化的字节大小) 2、大于32的用RoaringBitmap存储 1）：Byte(0) 2）：VarInt(SerializedSizeInBytes) RoaringBitmap需要序列化的字节大小
3）：RoaringBitmap的字节数组
综上转成java/scala代码：
import com.test.bitmap.VarInt import org.roaringbitmap.RoaringBitmap import org.roaringbitmap.buffer.{ImmutableRoaringBitmap, MutableRoaringBitmap} import java.io.{ByteArrayOutputStream, DataOutputStream} import java.nio.{ByteBuffer, ByteOrder} import java.util.Base64 object TestBitmapSeries { def main(args: Array[String]): Unit = { val rb = RoaringBitmap.bitmapOf(3, 4, 100) println("starting with bitmap " + rb) //当位图的基数少于32时，仅使用SmallSet存储 if (rb.getCardinality <= 32) { //分配缓冲区大小 val initBuffer = ByteBuffer.allocate(2 + 4 * rb.getCardinality) val bos = if (initBuffer.order eq ByteOrder.LITTLE_ENDIAN) initBuffer else initBuffer.slice.order(ByteOrder.LITTLE_ENDIAN) bos.put(new Integer(0).toByte) bos.put(rb.getCardinality.toByte) rb.toArray.foreach(i => bos.putInt(i)) val result = Base64.getEncoder.encodeToString(bos.array()) println("小于32的encode :"+result) } else { //rb.serializedSizeInBytes() 需要序列化的字节数 val seriesByteSize: Int = rb.serializedSizeInBytes() //VarInt.varIntSize返回编码需要的长度（二进制条件下:>>>） val varIntLen = VarInt.varIntSize(seriesByteSize) //初始化 val initBuffer: ByteBuffer = ByteBuffer.allocate(1 + varIntLen + rb.serializedSizeInBytes()) //字节高低序列,好像意思是在内存的存储方式 val bos = if (initBuffer.order eq ByteOrder.LITTLE_ENDIAN) initBuffer else initBuffer.slice.order(ByteOrder.LITTLE_ENDIAN) bos.put(new Integer(1).toByte) //TODO VarInt.putVarInt(rb.serializedSizeInBytes(), bos) val baos = new ByteArrayOutputStream() rb.serialize(new DataOutputStream(baos)) bos.put(baos.toByteArray()) val result: String = Base64.getEncoder.encodeToString(bos.array()) println("大于32的encode :"+result) } } }
结果和Clickhouse的编解码一致
5、利用sparkSql批量序列化RoaringBitmap，然后写入clickhouse
https://github.com/niutaofan/spark_bitmap.git
