如何设计table这种请求？
How to design table about such kind of request?
我正在尝试使用 Cassandra 作为消息系统的数据库。我将所有消息保存到一个 table 中，该 table 保存了我稍后将查询的所有必需数据。
现在我有一个请求，我必须显示用户最近 10 个聊天室的最新 100 条消息。聊天室需要按上次访问时间排序
我计划创建一个 table 让我持续 10 个聊天室并按他们的访问时间排序。
但是我想不出怎么设计table。我目前通过创建 table 和
来执行此类请求
用户，聊天室，access_time。并使用 (user, chatroom) 作为主键。
然后我每次收到消息时都会更新 access_time。
所以我可能会有这样的table
user chatroom time
1 2 1005
2 1 1000
1 3 1003
1 4 1004.
我很容易得到用户 1 的列表
1, 2, 1005,
1, 3, 1003,
1, 4, 1004.
我自己重新下单得到的
1, 3, 1003.
1, 4, 1004.
1, 2, 1005.
这就是我需要的最新结果。我需要 [3, 4, 2] 作为最终结果。
但是我想不出一个关于如何在 Cassandra 中进行排序的好方法。
Table 有更好的设计吗？
一般来说，聊天室不应该是一个大名单。所以即使我自己排序，排序时间应该也不是问题。
谢谢~~
埃里克
我确实尝试了 Mandraenke 的评论。但我的输入是这样的：
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo2', toTimeStamp(now()), 'room_4');
INSERT INTO room_access (user, when, room) VALUES ( 'demo3', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo2', toTimeStamp(now()), 'room_4');
INSERT INTO room_access (user, when, room) VALUES ( 'demo3', toTimeStamp(now()), 'room_3');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_4');
INSERT INTO room_access (user, when, room) VALUES ( 'demo4', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo5', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_3');
INSERT INTO room_access (user, when, room) VALUES ( 'demo7', toTimeStamp(now()), 'room_4');
INSERT INTO room_access (user, when, room) VALUES ( 'demo6', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo8', toTimeStamp(now()), 'room_5');
INSERT INTO room_access (user, when, room) VALUES ( 'demo9', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_7');
INSERT INTO room_access (user, when, room) VALUES ( 'demo2', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo3', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo5', toTimeStamp(now()), 'room_3');
INSERT INTO room_access (user, when, room) VALUES ( 'demo6', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo7', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo2', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo3', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_3');
INSERT INTO room_access (user, when, room) VALUES ( 'demo7', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo6', toTimeStamp(now()), 'room_5');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_8');
INSERT INTO room_access (user, when, room) VALUES ( 'demo2', toTimeStamp(now()), 'room_3');
INSERT INTO room_access (user, when, room) VALUES ( 'demo3', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo5', toTimeStamp(now()), 'room_3');
INSERT INTO room_access (user, when, room) VALUES ( 'demo6', toTimeStamp(now()), 'room_4');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo7', toTimeStamp(now()), 'room_3');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo2', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo3', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo6', toTimeStamp(now()), 'room_3');
INSERT INTO room_access (user, when, room) VALUES ( 'demo6', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo2', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo2', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo2', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo2', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo2', toTimeStamp(now()), 'room_3');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo4', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo6', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo2', toTimeStamp(now()), 'room_3');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_3');
INSERT INTO room_access (user, when, room) VALUES ( 'demo2', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo3', toTimeStamp(now()), 'room_1');
我的查询结果：
select * from room_access where user='demo1';
将是
user | when | room
-------+---------------------------------+--------
demo1 | 2018-01-01 18:17:27.886000+0000 | room_3
demo1 | 2018-01-01 18:17:27.865000+0000 | room_1
demo1 | 2018-01-01 18:17:27.850000+0000 | room_2
demo1 | 2018-01-01 18:17:27.831000+0000 | room_2
demo1 | 2018-01-01 18:17:27.738000+0000 | room_1
demo1 | 2018-01-01 18:17:27.594000+0000 | room_2
demo1 | 2018-01-01 18:17:27.556000+0000 | room_1
demo1 | 2018-01-01 18:17:27.513000+0000 | room_1
demo1 | 2018-01-01 18:17:27.456000+0000 | room_8
demo1 | 2018-01-01 18:17:27.430000+0000 | room_1
demo1 | 2018-01-01 18:17:27.404000+0000 | room_3
demo1 | 2018-01-01 18:17:27.386000+0000 | room_1
demo1 | 2018-01-01 18:17:27.202000+0000 | room_7
demo1 | 2018-01-01 18:17:27.136000+0000 | room_3
demo1 | 2018-01-01 18:17:27.088000+0000 | room_4
demo1 | 2018-01-01 18:17:27.020000+0000 | room_2
demo1 | 2018-01-01 18:17:26.964000+0000 | room_2
demo1 | 2018-01-01 18:17:26.947000+0000 | room_1
demo1 | 2018-01-01 18:14:47.267000+0000 | room_1
由于访问时间修改频繁，实际结果会超过千条记录（示例中只有19条记录。）但我想要的实际结果是
user | when | room
-------+---------------------------------+--------
demo1 | 2018-01-01 18:17:27.886000+0000 | room_3
demo1 | 2018-01-01 18:17:27.865000+0000 | room_1
demo1 | 2018-01-01 18:17:27.850000+0000 | room_2
demo1 | 2018-01-01 18:17:27.456000+0000 | room_8
demo1 | 2018-01-01 18:17:27.202000+0000 | room_7
demo1 | 2018-01-01 18:17:27.088000+0000 | room_4
看来我还需要额外的过滤才能得到我想要的。
那么..是否有一种简单的方法来进行我想要的过滤？
在 Cassandra 中，您几乎总是对数据进行非规范化处理以适合您的查询。对于您的问题，只需跟踪访问时间，例如：
cqlsh:demo> create table room_access ( user text, when timestamp, room text, primary key (user, when) ) WITH CLUSTERING ORDER BY (when DESC);
table 的唯一目的是跟踪每个用户的最后访问时间。注意聚类列和降序：
让我们插入一些数据：
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_a');
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_b');
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_c');
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_d');
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_e');
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_f');
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_g');
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_h');
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_i');
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_j');
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_k');
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_l');
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_b');
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_a');
现在您可以select最后十个房间：
cqlsh:demo> SELECT room FROM room_access WHERE user='demo' limit 10;
room
--------
room_a
room_b
room_l
room_k
room_j
room_i
room_h
room_g
room_f
room_e
(10 rows)
cqlsh:demo>
我正在尝试使用 Cassandra 作为消息系统的数据库。我将所有消息保存到一个 table 中，该 table 保存了我稍后将查询的所有必需数据。 现在我有一个请求，我必须显示用户最近 10 个聊天室的最新 100 条消息。聊天室需要按上次访问时间排序
我计划创建一个 table 让我持续 10 个聊天室并按他们的访问时间排序。
但是我想不出怎么设计table。我目前通过创建 table 和
来执行此类请求用户，聊天室，access_time。并使用 (user, chatroom) 作为主键。
然后我每次收到消息时都会更新 access_time。 所以我可能会有这样的table
user chatroom time
1 2 1005
2 1 1000
1 3 1003
1 4 1004.
我很容易得到用户 1 的列表
1, 2, 1005,
1, 3, 1003,
1, 4, 1004.
我自己重新下单得到的
1, 3, 1003.
1, 4, 1004.
1, 2, 1005.
这就是我需要的最新结果。我需要 [3, 4, 2] 作为最终结果。 但是我想不出一个关于如何在 Cassandra 中进行排序的好方法。 Table 有更好的设计吗？ 一般来说，聊天室不应该是一个大名单。所以即使我自己排序，排序时间应该也不是问题。
谢谢~~
埃里克
我确实尝试了 Mandraenke 的评论。但我的输入是这样的：
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo2', toTimeStamp(now()), 'room_4');
INSERT INTO room_access (user, when, room) VALUES ( 'demo3', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo2', toTimeStamp(now()), 'room_4');
INSERT INTO room_access (user, when, room) VALUES ( 'demo3', toTimeStamp(now()), 'room_3');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_4');
INSERT INTO room_access (user, when, room) VALUES ( 'demo4', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo5', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_3');
INSERT INTO room_access (user, when, room) VALUES ( 'demo7', toTimeStamp(now()), 'room_4');
INSERT INTO room_access (user, when, room) VALUES ( 'demo6', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo8', toTimeStamp(now()), 'room_5');
INSERT INTO room_access (user, when, room) VALUES ( 'demo9', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_7');
INSERT INTO room_access (user, when, room) VALUES ( 'demo2', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo3', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo5', toTimeStamp(now()), 'room_3');
INSERT INTO room_access (user, when, room) VALUES ( 'demo6', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo7', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo2', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo3', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_3');
INSERT INTO room_access (user, when, room) VALUES ( 'demo7', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo6', toTimeStamp(now()), 'room_5');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_8');
INSERT INTO room_access (user, when, room) VALUES ( 'demo2', toTimeStamp(now()), 'room_3');
INSERT INTO room_access (user, when, room) VALUES ( 'demo3', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo5', toTimeStamp(now()), 'room_3');
INSERT INTO room_access (user, when, room) VALUES ( 'demo6', toTimeStamp(now()), 'room_4');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo7', toTimeStamp(now()), 'room_3');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo2', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo3', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo6', toTimeStamp(now()), 'room_3');
INSERT INTO room_access (user, when, room) VALUES ( 'demo6', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo2', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo2', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo2', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo2', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo2', toTimeStamp(now()), 'room_3');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo4', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo6', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo2', toTimeStamp(now()), 'room_3');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_1');
INSERT INTO room_access (user, when, room) VALUES ( 'demo1', toTimeStamp(now()), 'room_3');
INSERT INTO room_access (user, when, room) VALUES ( 'demo2', toTimeStamp(now()), 'room_2');
INSERT INTO room_access (user, when, room) VALUES ( 'demo3', toTimeStamp(now()), 'room_1');
我的查询结果：
select * from room_access where user='demo1';
将是
user | when | room
-------+---------------------------------+--------
demo1 | 2018-01-01 18:17:27.886000+0000 | room_3
demo1 | 2018-01-01 18:17:27.865000+0000 | room_1
demo1 | 2018-01-01 18:17:27.850000+0000 | room_2
demo1 | 2018-01-01 18:17:27.831000+0000 | room_2
demo1 | 2018-01-01 18:17:27.738000+0000 | room_1
demo1 | 2018-01-01 18:17:27.594000+0000 | room_2
demo1 | 2018-01-01 18:17:27.556000+0000 | room_1
demo1 | 2018-01-01 18:17:27.513000+0000 | room_1
demo1 | 2018-01-01 18:17:27.456000+0000 | room_8
demo1 | 2018-01-01 18:17:27.430000+0000 | room_1
demo1 | 2018-01-01 18:17:27.404000+0000 | room_3
demo1 | 2018-01-01 18:17:27.386000+0000 | room_1
demo1 | 2018-01-01 18:17:27.202000+0000 | room_7
demo1 | 2018-01-01 18:17:27.136000+0000 | room_3
demo1 | 2018-01-01 18:17:27.088000+0000 | room_4
demo1 | 2018-01-01 18:17:27.020000+0000 | room_2
demo1 | 2018-01-01 18:17:26.964000+0000 | room_2
demo1 | 2018-01-01 18:17:26.947000+0000 | room_1
demo1 | 2018-01-01 18:14:47.267000+0000 | room_1
由于访问时间修改频繁，实际结果会超过千条记录（示例中只有19条记录。）但我想要的实际结果是
user | when | room
-------+---------------------------------+--------
demo1 | 2018-01-01 18:17:27.886000+0000 | room_3
demo1 | 2018-01-01 18:17:27.865000+0000 | room_1
demo1 | 2018-01-01 18:17:27.850000+0000 | room_2
demo1 | 2018-01-01 18:17:27.456000+0000 | room_8
demo1 | 2018-01-01 18:17:27.202000+0000 | room_7
demo1 | 2018-01-01 18:17:27.088000+0000 | room_4
看来我还需要额外的过滤才能得到我想要的。 那么..是否有一种简单的方法来进行我想要的过滤？
在 Cassandra 中，您几乎总是对数据进行非规范化处理以适合您的查询。对于您的问题，只需跟踪访问时间，例如：
cqlsh:demo> create table room_access ( user text, when timestamp, room text, primary key (user, when) ) WITH CLUSTERING ORDER BY (when DESC);
table 的唯一目的是跟踪每个用户的最后访问时间。注意聚类列和降序：
让我们插入一些数据：
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_a');
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_b');
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_c');
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_d');
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_e');
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_f');
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_g');
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_h');
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_i');
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_j');
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_k');
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_l');
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_b');
cqlsh:demo> INSERT INTO room_access (user, when, room) VALUES ( 'demo', toTimeStamp(now()), 'room_a');
现在您可以select最后十个房间：
cqlsh:demo> SELECT room FROM room_access WHERE user='demo' limit 10;
room
--------
room_a
room_b
room_l
room_k
room_j
room_i
room_h
room_g
room_f
room_e
(10 rows)
cqlsh:demo>