使用scyllaDb 或者cassandra存储聊天记录

飞鸟真人2024-01-28 10:27

一、使用scyllaDb的原因

目前开源的聊天软件主要还是使用mysql存储数据，数据量大的时候比较麻烦；

我打算使用scyllaDB存储用户的聊天记录，主要考虑的优点是：

1）方便后期线性扩展服务器；

2）partition更方便，clustering 可以将一组数据放在一起，加载更快；

我的后端服务使用go来写，

使用的库为https://github.com/scylladb/gocqlx/，目前版本为2.8

go get -u github.com/scylladb/gocqlx/v2

二、测试代码

1. 连接数据库

cluster := gocql.NewCluster("127.0.0.1:9042")
	cluster.Keyspace = "chatdata"
	cluster.Authenticator = gocql.PasswordAuthenticator{
		Username: "cassandra",
		Password: "cassandra",
	}
	session, err := cluster.CreateSession()
	if err != nil {
		fmt.Println("创建会话时发生错误:", err)
		return
	}
	defer session.Close()

	sessionx, err := gocqlx.WrapSession(session, nil)
	if err != nil {
	}
	defer sessionx.Close()

我是测试的机器，只有一个节点，后续在数据一致性要求也都写一个节点；

2. 定义数据结构

P2P的聊天，使用如下表：

Go 复制代码 
CREATE TABLE pchat (
    pk int,        // 分区
    uid1 bigint,   // 用户自己，P2P时写扩散，每个用户存储一份数据
	uid2 bigint,   // 对方
	id bigint,     // 消息全局唯一ID，服务器分配
	usid bigint,   // 发送方的消息唯一标记
    tm timestamp,   // 时间戳
	tm1 timestamp,  // 接收
    tm2 timestamp,  // 已读
    draf text,      // 数据
    io boolean,     // 收，发
	del boolean,    // 删除标记
    t smallint,     // 消息类型
    PRIMARY KEY (pk, uid1, tm, id)
	
)

在 Cassandra 中，PRIMARY KEY 的定义影响了数据如何进行分区（Partitioning）和在分区内如何进行排序（Clustering）。对于表定义 PRIMARY KEY (pk, uid1, tm, id)，它的影响如下：

  1. 分区键 (pk): 数据将按照 pk 的值进行分区。相同 pk 的数据会被存储在同一分区中。

  2. 聚簇键 (uid1,tm, id): 在同一分区内，数据将按照 (uid1, tm, id) 进行排序。这意味着相同 pk 的分区内的数据将按照 uid1 的值进行子分区，然后在每个子分区内按照 tm, id 的值进行排序。

简单来说，数据会先按照 pk 进行分区，然后在每个分区内，按照 (uid1, tm, id) 进行排序。这样的设计允许你在查询时方便地按照 pk、uid1 和tm, id 进行范围查询。

  • 一对一的聊天，都是2个用户，使用写扩散方式每个用户1份数据，这样的的好处是，使用用户ID聚簇，可以提高加载速度。并且减少数据的加载次数，具体在用户的会话区分上，可以在客户端一侧，执行本地的SQLITE存储。
  • 对比tinode的策略，它是按照每个会话做一个逻辑，需要管理当前所有的会话，逐个加载或者订阅，而且在测试过程中发现BUG，当如同微信一样删除了某个会话，等于拉了黑名单，无法后续会话了，这个不符合我们的习惯。
  • 对于群组聊天，可以使用读扩散的方式，因为写扩散毕竟太占用系统资源了；按照组ID来聚簇；

相关代码如下：

Go 复制代码 
// 定义表的元数据
var pchatMetadata = table.Metadata{
	Name:    "pchat",
	Columns: []string{"pk", "uid1", "uid2", "id", "usid", "tm", "tm1", "tm2", "draf", "io", "del", "t"},
	PartKey: []string{"pk"},
	SortKey: []string{"uid1", "id"},
}

// 创建表对象
var pchatTable = table.New(pchatMetadata)

// 定义数据结构
type PchatData struct {
	Pk   int       `db:"pk"`
	Uid1 int       `db:"uid1"`
	Uid2 int       `db:"uid2"`
	Id   int       `db:"id"`
	Usid int       `db:"usid"`
	Tm   time.Time `db:"tm"`
	Tm1  time.Time `db:"tm1"`
	Tm2  time.Time `db:"tm2"`
	Draf string    `db:"draf"`
	Io   bool      `db:"io"`
	Del  bool      `db:"del"`
	T    int       `db:"t"`
}

func PchatDataToSlice(data PchatData) []interface{} {
	return []interface{}{
		data.Pk,
		data.Uid1,
		data.Uid2,
		data.Id,
		data.Usid,
		data.Tm,
		data.Tm1,
		data.Tm2,
		data.Draf,
		data.Io,
		data.Del,
		data.T,
	}
}

3. 单条数据写入

Go 复制代码 
func insertData(session *gocqlx.Session) error {
	data := PchatData{
		Pk:   1,
		Uid1: 123456,
		Uid2: 789012,
		Id:   987654,
		Usid: 654321,
		Tm:   time.Now(),
		Tm1:  time.UnixMilli(0),
		Tm2:  time.UnixMilli(0),
		Draf: "你的草稿内容",
		Io:   true,
		Del:  false,
		T:    42,
	}

	// Insert using query builder.
	insertChat := qb.Insert("chatdata.pchat").Columns(pchatMetadata.Columns...).Query(*session).Consistency(gocql.One)

	insertChat.BindStruct(data)
	if err := insertChat.ExecRelease(); err != nil {
		fmt.Println(err)
		return err
	}

	return nil
}

4. 批量插入

Go 复制代码 
func insertBatch(session *gocqlx.Session) error {

	// 创建 Batch
	batch := session.Session.NewBatch(gocql.LoggedBatch)
	// 创建 Batch
	//batch := gocql.NewBatch(gocql.LoggedBatch)
	batch.Cons = gocql.LocalOne

	index := 1
	// 构建多个插入语句
	for i := index; i < index+1000; i++ {
		data := PchatData{
			Pk:   1,
			Uid1: 1001,
			Uid2: 1005,
			Id:   i,
			Usid: i,
			Tm:   time.Now(),
			Tm1:  time.UnixMilli(0),
			Tm2:  time.UnixMilli(0),
			Draf: "你的草稿内容",
			Io:   true,
			Del:  false,
			T:    1,
		}

		insertChatQry := qb.Insert("chatdata.pchat").Columns(pchatMetadata.Columns...).Query(*session).Consistency(gocql.One)
		batch.Query(insertChatQry.Statement(),
			PchatDataToSlice(data)...)

	}

	if err := session.ExecuteBatch(batch); err != nil {
		return err
	}

	return nil
}

挺快的，我远程插入云主机，1000条数据，使用了50毫秒左右；

5. 查询所有

这里就是一个测试，真正使用中，不会这么用

Go 复制代码 
func queryData(session *gocqlx.Session) error {

	var dataList []PchatData

	q := qb.Select("chatdata.pchat").Columns(pchatMetadata.Columns...).Query(*session).Consistency(gocql.One)
	if err := q.Select(&dataList); err != nil {
		return err
	}

	//for _, c := range dataList {
	//	fmt.Printf("%+v \n", c)
	//}

	for _, d := range dataList {
		fmt.Printf("pk: %d, uid1: %d, uid2: %d, id: %d, usid: %d, tm: %v, tm1: %v, tm2: %v, draf: %s, io: %t, del: %t, t: %d\n",
			d.Pk, d.Uid1, d.Uid2, d.Id, d.Usid, d.Tm, d.Tm1, d.Tm2, d.Draf, d.Io, d.Del, d.T)
	}
	return nil
}

6. 游标与分页

库内部提供了一些分页机制，但是我总觉得似乎不是我想要的；测试发现比较慢，目前没深入去研究内部机制：

Go 复制代码 
func queryDataByPage(session *gocqlx.Session) error {

	var pageSize = 10

	//chatTable := table.New(pchatMetadata)
	builder := qb.Select("chatdata.pchat").Columns(pchatMetadata.Columns...)
	builder.Where(qb.Eq("uid1"))
	builder.AllowFiltering()

	q := builder.Query(*session)
	defer q.Release()
	q.PageSize(pageSize)
	q.Consistency(gocql.One)
	q.Bind(1001)

	getUserChatFunc := func(userID int64, page []byte) (chats []PchatData, nextPage []byte, err error) {
		if len(page) > 0 {
			q.PageState(page)
		}
		iter := q.Iter()
		return chats, iter.PageState(), iter.Select(&chats)
	}

	var (
		dataList []PchatData
		nextPage []byte
		err      error
	)

	for i := 1; ; i++ {
		dataList, nextPage, err = getUserChatFunc(1001, nextPage)
		if err != nil {
			fmt.Println(err)
			return err
		}

		fmt.Printf("Page %d: \n", i)
		for _, d := range dataList {
			//fmt.Printf("pk: %d, uid1: %d, uid2: %d, id: %d, usid: %d, tm: %v, tm1: %v, tm2: %v, draf: %s, io: %t, del: %t, t: %d\n",
			//	d.Pk, d.Uid1, d.Uid2, d.Id, d.Usid, d.Tm, d.Tm1, d.Tm2, d.Draf, d.Io, d.Del, d.T)

			fmt.Printf("pk: %d, uid1: %d, uid2: %d, id: %d \n", d.Pk, d.Uid1, d.Uid2, d.Id)
		}
		if len(nextPage) == 0 {
			break
		}
	}

	return nil
}

7. 按用户与id号来加载

我设想的用法是，既然按照user id 聚簇了，支持多个客户端使用时，某个客户端初次加载（冷加载），可以加载最近的部分，然后根据需要在根据条件加载；持续更新的用户（热加载）首先是考虑从redis中加载，已经落库的部分再根据时间段加载；

这里测试的是，从某个ID=900的条目之后，加载10条

Go 复制代码 
func queryDataByIdPage(session *gocqlx.Session) error {

	var pageSize uint = 10

	//chatTable := table.New(pchatMetadata)
	builder := qb.Select("chatdata.pchat").Columns(pchatMetadata.Columns...)
	builder.Where(qb.Eq("uid1"), qb.Gt("id"))

	builder.AllowFiltering()
	builder.Limit(pageSize)

	q := builder.Query(*session)
	defer q.Release()
	q.Consistency(gocql.One)
	q.Bind(1002, 900)

	var dataList []PchatData

	err := q.Select(&dataList)
	if err != nil {
		fmt.Println(err)
		return err
	}

	fmt.Printf("size= %d: \n", len(dataList))
	for _, d := range dataList {
		//fmt.Printf("pk: %d, uid1: %d, uid2: %d, id: %d, usid: %d, tm: %v, tm1: %v, tm2: %v, draf: %s, io: %t, del: %t, t: %d\n",
		//	d.Pk, d.Uid1, d.Uid2, d.Id, d.Usid, d.Tm, d.Tm1, d.Tm2, d.Draf, d.Io, d.Del, d.T)

		fmt.Printf("pk: %d, uid1: %d, uid2: %d, id: %d tm: %v \n", d.Pk, d.Uid1, d.Uid2, d.Id, d.Tm)
	}

	return nil
}

8. 按照时间范围来找

Go 复制代码 
func string2timeLoc(dateString string) (time.Time, error) {
	// 设置东八区（中国标准时间）的地理位置
	loc, err := time.LoadLocation("Asia/Shanghai")
	if err != nil {
		fmt.Println("加载地理位置错误:", err)
		return time.Now(), err
	}

	// 使用地理位置信息进行日期解析
	parsedTime, err := time.ParseInLocation("2006-01-02 15:04:05", dateString, loc)
	if err != nil {
		fmt.Println("日期解析错误:", err)
		return time.Now(), err
	}

	return parsedTime, nil
}
func queryDataBytmPage(session *gocqlx.Session) error {

	//var pageSize uint = 10

	//chatTable := table.New(pchatMetadata)
	builder := qb.Select("chatdata.pchat").Columns(pchatMetadata.Columns...)
	builder.Where(qb.Eq("uid1"), qb.GtOrEq("tm"), qb.LtOrEq("tm"))

	builder.AllowFiltering()
	//builder.Limit(pageSize)

	q := builder.Query(*session)
	defer q.Release()
	q.Consistency(gocql.One)
	tm1, _ := string2timeLoc("2024-01-27 13:24:00")
	tm2, _ := string2timeLoc("2024-01-27 13:25:56")
	q.Bind(1001, tm1, tm2)

	var dataList []PchatData

	err := q.Select(&dataList)
	if err != nil {
		fmt.Println(err)
		return err
	}

	fmt.Printf("size= %d: \n", len(dataList))
	for _, d := range dataList {
		//fmt.Printf("pk: %d, uid1: %d, uid2: %d, id: %d, usid: %d, tm: %v, tm1: %v, tm2: %v, draf: %s, io: %t, del: %t, t: %d\n",
		//	d.Pk, d.Uid1, d.Uid2, d.Id, d.Usid, d.Tm, d.Tm1, d.Tm2, d.Draf, d.Io, d.Del, d.T)

		fmt.Printf("pk: %d, uid1: %d, uid2: %d, id: %d tm: %v \n", d.Pk, d.Uid1, d.Uid2, d.Id, d.Tm)
	}

	return nil
}

9. 倒序

这个库的说明并不详细，readme.md还是过时的，chatgtp给的信息也是错误很多，目前根据测试发现，在设置排序方式时：

在 Cassandra 中，ORDER BY 子句需要按照聚簇键的声明顺序指定。在表定义中，聚簇键是 (uid1, tm, id)，所以需要按照这个顺序指定 ORDER BY。

在代码中，需要按照以下方式指定 ORDER BY：

Go 复制代码 
builder := qb.Select("chatdata.pchat").Columns(pchatMetadata.Columns...)
	builder.Where(qb.Eq("pk"), qb.Eq("uid1"), qb.GtOrEq("tm"), qb.LtOrEq("tm"))

	builder.OrderBy("uid1", qb.DESC)
	//builder.OrderBy("tm", qb.DESC)
	//builder.OrderBy("id", qb.DESC)
    // 写一个就够了

	builder.AllowFiltering()
	//builder.Limit(pageSize)

	q := builder.Query(*session)
	defer q.Release()
	q.Consistency(gocql.One)
	tm1, _ := string2timeLoc("2024-01-27 13:24:00")
	tm2, _ := string2timeLoc("2024-01-27 13:25:56")
	q.Bind(1, 1001, tm1, tm2)

其中，pk 作为分区键，不能排序，而聚簇的键需要按照顺序指定，其中不能混！要么都是升序，要么都是降序，否则执行时候报错"Unsupported order by relation"。

相关推荐
向前看-1 小时前
验证码机制
前端·后端
超爱吃士力架3 小时前
邀请逻辑
java·linux·后端
AskHarries5 小时前
Spring Cloud OpenFeign快速入门demo
spring boot·后端
isolusion6 小时前
Springboot的创建方式
java·spring boot·后端
zjw_rp6 小时前
Spring-AOP
java·后端·spring·spring-aop
TodoCoder7 小时前
【编程思想】CopyOnWrite是如何解决高并发场景中的读写瓶颈？
java·后端·面试
凌虚7 小时前
Kubernetes APF（API 优先级和公平调度）简介
后端·程序员·kubernetes
机器之心8 小时前
图学习新突破：一个统一框架连接空域和频域
人工智能·后端
.生产的驴9 小时前
SpringBoot 对接第三方登录 手机号登录 手机号验证 微信小程序登录 结合Redis SaToken
java·spring boot·redis·后端·缓存·微信小程序·maven
顽疲9 小时前
springboot vue 会员收银系统 含源码 开发流程
vue.js·spring boot·后端
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04DisplayPort AltMode On Type-c协议_Ver2.0(学习笔记)05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问076个主流的工业3D管道设计软件08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10树莓派 5 AI 套件（Hailo-8L）使用教程