使用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"。

相关推荐
Ljw...5 分钟前
表的增删改查（MySQL）
数据库·后端·mysql·表的增删查改
编程重生之路5 分钟前
Springboot启动异常 错误: 找不到或无法加载主类 xxx.Application异常
java·spring boot·后端
薯条不要番茄酱5 分钟前
数据结构-8.Java. 七大排序算法(中篇)
java·开发语言·数据结构·后端·算法·排序算法·intellij-idea
qq_17448285758 小时前
springboot基于微信小程序的旧衣回收系统的设计与实现
spring boot·后端·微信小程序
锅包肉的九珍9 小时前
Scala的Array数组
开发语言·后端·scala
心仪悦悦9 小时前
Scala的Array（2）
开发语言·后端·scala
2401_882727579 小时前
BY组态-低代码web可视化组件
前端·后端·物联网·低代码·数学建模·前端框架
心仪悦悦10 小时前
Scala中的集合复习（1）
开发语言·后端·scala
代码小鑫10 小时前
A043-基于Spring Boot的秒杀系统设计与实现
java·开发语言·数据库·spring boot·后端·spring·毕业设计
真心喜欢你吖10 小时前
SpringBoot与MongoDB深度整合及应用案例
java·spring boot·后端·mongodb·spring
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10怎样让音频速度变慢？请跟随以下方法进行操作