Unified · Split
| @@ -1444,6 +1444,7 @@ dependencies = [ · 1443 unmodified lines | ||
| 1444 | 1444 | "pretty_assertions", |
| 1445 | 1445 | "project", |
| 1446 | 1446 | "prometheus", |
| 1447 | + "prost 0.8.0", | |
| 1447 | 1448 | "rand 0.8.5", |
| 1448 | 1449 | "reqwest", |
| 1449 | 1450 | "rpc", |
| @@ -1456,6 +1457,7 @@ dependencies = [ · 6 unmodified lines | ||
| 1456 | 1457 | "settings", |
| 1457 | 1458 | "sha-1 0.9.8", |
| 1458 | 1459 | "sqlx", |
| 1460 | + "text", | |
| 1459 | 1461 | "theme", |
| 1460 | 1462 | "time 0.3.24", |
| 1461 | 1463 | "tokio", |
| @@ -96,6 +96,7 @@ log = { version = "0.4.16", features = ["kv_unstable_serde"] } · 95 unmodified lines | ||
| 96 | 96 | ordered-float = { version = "2.1.1" } |
| 97 | 97 | parking_lot = { version = "0.11.1" } |
| 98 | 98 | postage = { version = "0.5", features = ["futures-traits"] } |
| 99 | +prost = { version = "0.8" } | |
| 99 | 100 | rand = { version = "0.8.5" } |
| 100 | 101 | refineable = { path = "./crates/refineable" } |
| 101 | 102 | regex = { version = "1.5" } |
| @@ -16,6 +16,7 @@ required-features = ["seed-support"] · 15 unmodified lines | ||
| 16 | 16 | [dependencies] |
| 17 | 17 | collections = { path = "../collections" } |
| 18 | 18 | live_kit_server = { path = "../live_kit_server" } |
| 19 | +text = { path = "../text" } | |
| 19 | 20 | rpc = { path = "../rpc" } |
| 20 | 21 | util = { path = "../util" } |
| 21 | 22 | |
| @@ -35,6 +36,7 @@ log.workspace = true · 13 unmodified lines | ||
| 35 | 36 | nanoid = "0.4" |
| 36 | 37 | parking_lot.workspace = true |
| 37 | 38 | prometheus = "0.13" |
| 39 | +prost.workspace = true | |
| 38 | 40 | rand.workspace = true |
| 39 | 41 | reqwest = { version = "0.11", features = ["json"], optional = true } |
| 40 | 42 | scrypt = "0.7" |
| @@ -189,7 +189,8 @@ CREATE INDEX "index_followers_on_room_id" ON "followers" ("room_id"); · 188 unmodified lines | ||
| 189 | 189 | CREATE TABLE "channels" ( |
| 190 | 190 | "id" INTEGER PRIMARY KEY AUTOINCREMENT, |
| 191 | 191 | "name" VARCHAR NOT NULL, |
| 192 | − "created_at" TIMESTAMP NOT NULL DEFAULT now | |
| 192 | + "created_at" TIMESTAMP NOT NULL DEFAULT now, | |
| 193 | + "main_buffer_id" INTEGER REFERENCES buffers (id) | |
| 193 | 194 | ); |
| 194 | 195 | |
| 195 | 196 | CREATE TABLE "channel_paths" ( |
| @@ -208,3 +209,27 @@ CREATE TABLE "channel_members" ( · 12 unmodified lines | ||
| 208 | 209 | ); |
| 209 | 210 | |
| 210 | 211 | CREATE UNIQUE INDEX "index_channel_members_on_channel_id_and_user_id" ON "channel_members" ("channel_id", "user_id"); |
| 212 | + | |
| 213 | +CREATE TABLE "buffers" ( | |
| 214 | + "id" INTEGER PRIMARY KEY AUTOINCREMENT, | |
| 215 | + "epoch" INTEGER NOT NULL DEFAULT 0 | |
| 216 | +); | |
| 217 | + | |
| 218 | +CREATE TABLE "buffer_operations" ( | |
| 219 | + "buffer_id" INTEGER NOT NULL REFERENCES buffers (id) ON DELETE CASCADE, | |
| 220 | + "epoch" INTEGER NOT NULL, | |
| 221 | + "replica_id" INTEGER NOT NULL, | |
| 222 | + "lamport_timestamp" INTEGER NOT NULL, | |
| 223 | + "local_timestamp" INTEGER NOT NULL, | |
| 224 | + "version" BLOB NOT NULL, | |
| 225 | + "is_undo" BOOLEAN NOT NULL, | |
| 226 | + "value" BLOB NOT NULL, | |
| 227 | + PRIMARY KEY(buffer_id, epoch, lamport_timestamp, replica_id) | |
| 228 | +); | |
| 229 | + | |
| 230 | +CREATE TABLE "buffer_snapshots" ( | |
| 231 | + "buffer_id" INTEGER NOT NULL REFERENCES buffers (id) ON DELETE CASCADE, | |
| 232 | + "epoch" INTEGER NOT NULL, | |
| 233 | + "text" TEXT NOT NULL, | |
| 234 | + PRIMARY KEY(buffer_id, epoch) | |
| 235 | +); | |
| @@ -0,0 +1,25 @@ | ||
| 1 | +CREATE TABLE "buffers" ( | |
| 2 | + "id" SERIAL PRIMARY KEY, | |
| 3 | + "epoch" INTEGER NOT NULL DEFAULT 0 | |
| 4 | +); | |
| 5 | + | |
| 6 | +CREATE TABLE "buffer_operations" ( | |
| 7 | + "buffer_id" INTEGER NOT NULL REFERENCES buffers (id) ON DELETE CASCADE, | |
| 8 | + "epoch" INTEGER NOT NULL, | |
| 9 | + "replica_id" INTEGER NOT NULL, | |
| 10 | + "local_timestamp" INTEGER NOT NULL, | |
| 11 | + "lamport_timestamp" INTEGER NOT NULL, | |
| 12 | + "version" BYTEA NOT NULL, | |
| 13 | + "is_undo" BOOLEAN NOT NULL, | |
| 14 | + "value" BYTEA NOT NULL, | |
| 15 | + PRIMARY KEY(buffer_id, epoch, lamport_timestamp, replica_id) | |
| 16 | +); | |
| 17 | + | |
| 18 | +CREATE TABLE "buffer_snapshots" ( | |
| 19 | + "buffer_id" INTEGER NOT NULL REFERENCES buffers (id) ON DELETE CASCADE, | |
| 20 | + "epoch" INTEGER NOT NULL, | |
| 21 | + "text" TEXT NOT NULL, | |
| 22 | + PRIMARY KEY(buffer_id, epoch) | |
| 23 | +); | |
| 24 | + | |
| 25 | +ALTER TABLE "channels" ADD COLUMN "main_buffer_id" INTEGER REFERENCES buffers (id); | |
| @@ -52,6 +52,8 @@ pub struct Database { · 51 unmodified lines | ||
| 52 | 52 | runtime: Option<tokio::runtime::Runtime>, |
| 53 | 53 | } |
| 54 | 54 | |
| 55 | +// The `Database` type has so many methods that its impl blocks are split into | |
| 56 | +// separate files in the `queries` folder. | |
| 55 | 57 | impl Database { |
| 56 | 58 | pub async fn new(options: ConnectOptions, executor: Executor) -> Result<Self> { |
| 57 | 59 | Ok(Self { |
| @@ -110,6 +110,7 @@ fn value_to_integer(v: Value) -> Result<i32, ValueTypeErr> { · 109 unmodified lines | ||
| 110 | 110 | } |
| 111 | 111 | } |
| 112 | 112 | |
| 113 | +id_type!(BufferId); | |
| 113 | 114 | id_type!(AccessTokenId); |
| 114 | 115 | id_type!(ChannelId); |
| 115 | 116 | id_type!(ChannelMemberId); |
| @@ -1,6 +1,7 @@ | ||
| 1 | 1 | use super::*; |
| 2 | 2 | |
| 3 | 3 | pub mod access_tokens; |
| 4 | +pub mod buffers; | |
| 4 | 5 | pub mod channels; |
| 5 | 6 | pub mod contacts; |
| 6 | 7 | pub mod projects; |
| @@ -8,3 +9,6 @@ pub mod rooms; · 1 unmodified line | ||
| 8 | 9 | pub mod servers; |
| 9 | 10 | pub mod signups; |
| 10 | 11 | pub mod users; |
| 12 | + | |
| 13 | +#[cfg(test)] | |
| 14 | +pub mod buffer_tests; | |
| @@ -0,0 +1,41 @@ | ||
| 1 | +use super::*; | |
| 2 | +use crate::test_both_dbs; | |
| 3 | +use language::proto; | |
| 4 | +use text::Buffer; | |
| 5 | + | |
| 6 | +test_both_dbs!(test_buffers, test_buffers_postgres, test_buffers_sqlite); | |
| 7 | + | |
| 8 | +async fn test_buffers(db: &Arc<Database>) { | |
| 9 | + let buffer_id = db.create_buffer().await.unwrap(); | |
| 10 | + | |
| 11 | + let mut buffer = Buffer::new(0, 0, "".to_string()); | |
| 12 | + let mut operations = Vec::new(); | |
| 13 | + operations.push(buffer.edit([(0..0, "hello world")])); | |
| 14 | + operations.push(buffer.edit([(5..5, ", cruel")])); | |
| 15 | + operations.push(buffer.edit([(0..5, "goodbye")])); | |
| 16 | + operations.push(buffer.undo().unwrap().1); | |
| 17 | + assert_eq!(buffer.text(), "hello, cruel world"); | |
| 18 | + | |
| 19 | + let operations = operations | |
| 20 | + .into_iter() | |
| 21 | + .map(|op| proto::serialize_operation(&language::Operation::Buffer(op))) | |
| 22 | + .collect::<Vec<_>>(); | |
| 23 | + | |
| 24 | + db.update_buffer(buffer_id, &operations).await.unwrap(); | |
| 25 | + | |
| 26 | + let buffer_data = db.get_buffer(buffer_id).await.unwrap(); | |
| 27 | + | |
| 28 | + let mut buffer_2 = Buffer::new(0, 0, buffer_data.base_text); | |
| 29 | + buffer_2 | |
| 30 | + .apply_ops(buffer_data.operations.into_iter().map(|operation| { | |
| 31 | + let operation = proto::deserialize_operation(operation).unwrap(); | |
| 32 | + if let language::Operation::Buffer(operation) = operation { | |
| 33 | + operation | |
| 34 | + } else { | |
| 35 | + unreachable!() | |
| 36 | + } | |
| 37 | + })) | |
| 38 | + .unwrap(); | |
| 39 | + | |
| 40 | + assert_eq!(buffer_2.text(), "hello, cruel world"); | |
| 41 | +} | |
| @@ -0,0 +1,271 @@ | ||
| 1 | +use super::*; | |
| 2 | +use prost::Message; | |
| 3 | + | |
| 4 | +pub struct Buffer { | |
| 5 | + pub base_text: String, | |
| 6 | + pub operations: Vec<proto::Operation>, | |
| 7 | +} | |
| 8 | + | |
| 9 | +impl Database { | |
| 10 | + pub async fn create_buffer(&self) -> Result<BufferId> { | |
| 11 | + self.transaction(|tx| async move { | |
| 12 | + let buffer = buffer::ActiveModel::new().insert(&*tx).await?; | |
| 13 | + Ok(buffer.id) | |
| 14 | + }) | |
| 15 | + .await | |
| 16 | + } | |
| 17 | + | |
| 18 | + pub async fn update_buffer( | |
| 19 | + &self, | |
| 20 | + buffer_id: BufferId, | |
| 21 | + operations: &[proto::Operation], | |
| 22 | + ) -> Result<()> { | |
| 23 | + self.transaction(|tx| async move { | |
| 24 | + let buffer = buffer::Entity::find_by_id(buffer_id) | |
| 25 | + .one(&*tx) | |
| 26 | + .await? | |
| 27 | + .ok_or_else(|| anyhow!("no such buffer"))?; | |
| 28 | + buffer_operation::Entity::insert_many(operations.iter().filter_map(|operation| { | |
| 29 | + match operation.variant.as_ref()? { | |
| 30 | + proto::operation::Variant::Edit(operation) => { | |
| 31 | + let value = | |
| 32 | + serialize_edit_operation(&operation.ranges, &operation.new_text); | |
| 33 | + let version = serialize_version(&operation.version); | |
| 34 | + Some(buffer_operation::ActiveModel { | |
| 35 | + buffer_id: ActiveValue::Set(buffer_id), | |
| 36 | + epoch: ActiveValue::Set(buffer.epoch), | |
| 37 | + replica_id: ActiveValue::Set(operation.replica_id as i32), | |
| 38 | + lamport_timestamp: ActiveValue::Set(operation.lamport_timestamp as i32), | |
| 39 | + local_timestamp: ActiveValue::Set(operation.local_timestamp as i32), | |
| 40 | + is_undo: ActiveValue::Set(false), | |
| 41 | + version: ActiveValue::Set(version), | |
| 42 | + value: ActiveValue::Set(value), | |
| 43 | + }) | |
| 44 | + } | |
| 45 | + proto::operation::Variant::Undo(operation) => { | |
| 46 | + let value = serialize_undo_operation(&operation.counts); | |
| 47 | + let version = serialize_version(&operation.version); | |
| 48 | + Some(buffer_operation::ActiveModel { | |
| 49 | + buffer_id: ActiveValue::Set(buffer_id), | |
| 50 | + epoch: ActiveValue::Set(buffer.epoch), | |
| 51 | + replica_id: ActiveValue::Set(operation.replica_id as i32), | |
| 52 | + lamport_timestamp: ActiveValue::Set(operation.lamport_timestamp as i32), | |
| 53 | + local_timestamp: ActiveValue::Set(operation.local_timestamp as i32), | |
| 54 | + is_undo: ActiveValue::Set(true), | |
| 55 | + version: ActiveValue::Set(version), | |
| 56 | + value: ActiveValue::Set(value), | |
| 57 | + }) | |
| 58 | + } | |
| 59 | + proto::operation::Variant::UpdateSelections(_) => None, | |
| 60 | + proto::operation::Variant::UpdateDiagnostics(_) => None, | |
| 61 | + proto::operation::Variant::UpdateCompletionTriggers(_) => None, | |
| 62 | + } | |
| 63 | + })) | |
| 64 | + .exec(&*tx) | |
| 65 | + .await?; | |
| 66 | + | |
| 67 | + Ok(()) | |
| 68 | + }) | |
| 69 | + .await | |
| 70 | + } | |
| 71 | + | |
| 72 | + pub async fn get_buffer(&self, id: BufferId) -> Result<Buffer> { | |
| 73 | + self.transaction(|tx| async move { | |
| 74 | + let buffer = buffer::Entity::find_by_id(id) | |
| 75 | + .one(&*tx) | |
| 76 | + .await? | |
| 77 | + .ok_or_else(|| anyhow!("no such buffer"))?; | |
| 78 | + | |
| 79 | + let base_text = if buffer.epoch > 0 { | |
| 80 | + buffer_snapshot::Entity::find() | |
| 81 | + .filter( | |
| 82 | + buffer_snapshot::Column::BufferId | |
| 83 | + .eq(id) | |
| 84 | + .and(buffer_snapshot::Column::Epoch.eq(buffer.epoch)), | |
| 85 | + ) | |
| 86 | + .one(&*tx) | |
| 87 | + .await? | |
| 88 | + .ok_or_else(|| anyhow!("no such snapshot"))? | |
| 89 | + .text | |
| 90 | + } else { | |
| 91 | + String::new() | |
| 92 | + }; | |
| 93 | + | |
| 94 | + let mut rows = buffer_operation::Entity::find() | |
| 95 | + .filter( | |
| 96 | + buffer_operation::Column::BufferId | |
| 97 | + .eq(id) | |
| 98 | + .and(buffer_operation::Column::Epoch.eq(buffer.epoch)), | |
| 99 | + ) | |
| 100 | + .stream(&*tx) | |
| 101 | + .await?; | |
| 102 | + let mut operations = Vec::new(); | |
| 103 | + while let Some(row) = rows.next().await { | |
| 104 | + let row = row?; | |
| 105 | + let version = deserialize_version(&row.version)?; | |
| 106 | + let operation = if row.is_undo { | |
| 107 | + let counts = deserialize_undo_operation(&row.value)?; | |
| 108 | + proto::operation::Variant::Undo(proto::operation::Undo { | |
| 109 | + replica_id: row.replica_id as u32, | |
| 110 | + local_timestamp: row.local_timestamp as u32, | |
| 111 | + lamport_timestamp: row.lamport_timestamp as u32, | |
| 112 | + version, | |
| 113 | + counts, | |
| 114 | + }) | |
| 115 | + } else { | |
| 116 | + let (ranges, new_text) = deserialize_edit_operation(&row.value)?; | |
| 117 | + proto::operation::Variant::Edit(proto::operation::Edit { | |
| 118 | + replica_id: row.replica_id as u32, | |
| 119 | + local_timestamp: row.local_timestamp as u32, | |
| 120 | + lamport_timestamp: row.lamport_timestamp as u32, | |
| 121 | + version, | |
| 122 | + ranges, | |
| 123 | + new_text, | |
| 124 | + }) | |
| 125 | + }; | |
| 126 | + operations.push(proto::Operation { | |
| 127 | + variant: Some(operation), | |
| 128 | + }) | |
| 129 | + } | |
| 130 | + | |
| 131 | + Ok(Buffer { | |
| 132 | + base_text, | |
| 133 | + operations, | |
| 134 | + }) | |
| 135 | + }) | |
| 136 | + .await | |
| 137 | + } | |
| 138 | +} | |
| 139 | + | |
| 140 | +mod storage { | |
| 141 | + #![allow(non_snake_case)] | |
| 142 | + | |
| 143 | + use prost::Message; | |
| 144 | + | |
| 145 | + pub const VERSION: usize = 1; | |
| 146 | + | |
| 147 | + #[derive(Message)] | |
| 148 | + pub struct VectorClock { | |
| 149 | + #[prost(message, repeated, tag = "1")] | |
| 150 | + pub entries: Vec<VectorClockEntry>, | |
| 151 | + } | |
| 152 | + | |
| 153 | + #[derive(Message)] | |
| 154 | + pub struct VectorClockEntry { | |
| 155 | + #[prost(uint32, tag = "1")] | |
| 156 | + pub replica_id: u32, | |
| 157 | + #[prost(uint32, tag = "2")] | |
| 158 | + pub timestamp: u32, | |
| 159 | + } | |
| 160 | + | |
| 161 | + #[derive(Message)] | |
| 162 | + pub struct TextEdit { | |
| 163 | + #[prost(message, repeated, tag = "1")] | |
| 164 | + pub ranges: Vec<Range>, | |
| 165 | + #[prost(string, repeated, tag = "2")] | |
| 166 | + pub texts: Vec<String>, | |
| 167 | + } | |
| 168 | + | |
| 169 | + #[derive(Message)] | |
| 170 | + pub struct Range { | |
| 171 | + #[prost(uint64, tag = "1")] | |
| 172 | + pub start: u64, | |
| 173 | + #[prost(uint64, tag = "2")] | |
| 174 | + pub end: u64, | |
| 175 | + } | |
| 176 | + | |
| 177 | + #[derive(Message)] | |
| 178 | + pub struct Undo { | |
| 179 | + #[prost(message, repeated, tag = "1")] | |
| 180 | + pub entries: Vec<UndoCount>, | |
| 181 | + } | |
| 182 | + | |
| 183 | + #[derive(Message)] | |
| 184 | + pub struct UndoCount { | |
| 185 | + #[prost(uint32, tag = "1")] | |
| 186 | + pub replica_id: u32, | |
| 187 | + #[prost(uint32, tag = "2")] | |
| 188 | + pub local_timestamp: u32, | |
| 189 | + #[prost(uint32, tag = "3")] | |
| 190 | + pub count: u32, | |
| 191 | + } | |
| 192 | +} | |
| 193 | + | |
| 194 | +fn serialize_version(version: &Vec<proto::VectorClockEntry>) -> Vec<u8> { | |
| 195 | + storage::VectorClock { | |
| 196 | + entries: version | |
| 197 | + .iter() | |
| 198 | + .map(|entry| storage::VectorClockEntry { | |
| 199 | + replica_id: entry.replica_id, | |
| 200 | + timestamp: entry.timestamp, | |
| 201 | + }) | |
| 202 | + .collect(), | |
| 203 | + } | |
| 204 | + .encode_to_vec() | |
| 205 | +} | |
| 206 | + | |
| 207 | +fn deserialize_version(bytes: &[u8]) -> Result<Vec<proto::VectorClockEntry>> { | |
| 208 | + let clock = storage::VectorClock::decode(bytes).map_err(|error| anyhow!("{}", error))?; | |
| 209 | + Ok(clock | |
| 210 | + .entries | |
| 211 | + .into_iter() | |
| 212 | + .map(|entry| proto::VectorClockEntry { | |
| 213 | + replica_id: entry.replica_id, | |
| 214 | + timestamp: entry.timestamp, | |
| 215 | + }) | |
| 216 | + .collect()) | |
| 217 | +} | |
| 218 | + | |
| 219 | +fn serialize_edit_operation(ranges: &[proto::Range], texts: &[String]) -> Vec<u8> { | |
| 220 | + storage::TextEdit { | |
| 221 | + ranges: ranges | |
| 222 | + .iter() | |
| 223 | + .map(|range| storage::Range { | |
| 224 | + start: range.start, | |
| 225 | + end: range.end, | |
| 226 | + }) | |
| 227 | + .collect(), | |
| 228 | + texts: texts.to_vec(), | |
| 229 | + } | |
| 230 | + .encode_to_vec() | |
| 231 | +} | |
| 232 | + | |
| 233 | +fn deserialize_edit_operation(bytes: &[u8]) -> Result<(Vec<proto::Range>, Vec<String>)> { | |
| 234 | + let edit = storage::TextEdit::decode(bytes).map_err(|error| anyhow!("{}", error))?; | |
| 235 | + let ranges = edit | |
| 236 | + .ranges | |
| 237 | + .into_iter() | |
| 238 | + .map(|range| proto::Range { | |
| 239 | + start: range.start, | |
| 240 | + end: range.end, | |
| 241 | + }) | |
| 242 | + .collect(); | |
| 243 | + Ok((ranges, edit.texts)) | |
| 244 | +} | |
| 245 | + | |
| 246 | +fn serialize_undo_operation(counts: &Vec<proto::UndoCount>) -> Vec<u8> { | |
| 247 | + storage::Undo { | |
| 248 | + entries: counts | |
| 249 | + .iter() | |
| 250 | + .map(|entry| storage::UndoCount { | |
| 251 | + replica_id: entry.replica_id, | |
| 252 | + local_timestamp: entry.local_timestamp, | |
| 253 | + count: entry.count, | |
| 254 | + }) | |
| 255 | + .collect(), | |
| 256 | + } | |
| 257 | + .encode_to_vec() | |
| 258 | +} | |
| 259 | + | |
| 260 | +fn deserialize_undo_operation(bytes: &[u8]) -> Result<Vec<proto::UndoCount>> { | |
| 261 | + let undo = storage::Undo::decode(bytes).map_err(|error| anyhow!("{}", error))?; | |
| 262 | + Ok(undo | |
| 263 | + .entries | |
| 264 | + .iter() | |
| 265 | + .map(|entry| proto::UndoCount { | |
| 266 | + replica_id: entry.replica_id, | |
| 267 | + local_timestamp: entry.local_timestamp, | |
| 268 | + count: entry.count, | |
| 269 | + }) | |
| 270 | + .collect()) | |
| 271 | +} | |
| @@ -1,4 +1,7 @@ | ||
| 1 | 1 | pub mod access_token; |
| 2 | +pub mod buffer; | |
| 3 | +pub mod buffer_operation; | |
| 4 | +pub mod buffer_snapshot; | |
| 2 | 5 | pub mod channel; |
| 3 | 6 | pub mod channel_member; |
| 4 | 7 | pub mod channel_path; |
| @@ -0,0 +1,32 @@ | ||
| 1 | +use crate::db::BufferId; | |
| 2 | +use sea_orm::entity::prelude::*; | |
| 3 | + | |
| 4 | +#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)] | |
| 5 | +#[sea_orm(table_name = "buffers")] | |
| 6 | +pub struct Model { | |
| 7 | + #[sea_orm(primary_key)] | |
| 8 | + pub id: BufferId, | |
| 9 | + pub epoch: i32, | |
| 10 | +} | |
| 11 | + | |
| 12 | +#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)] | |
| 13 | +pub enum Relation { | |
| 14 | + #[sea_orm(has_many = "super::buffer_operation::Entity")] | |
| 15 | + Operations, | |
| 16 | + #[sea_orm(has_many = "super::buffer_snapshot::Entity")] | |
| 17 | + Snapshots, | |
| 18 | +} | |
| 19 | + | |
| 20 | +impl Related<super::buffer_operation::Entity> for Entity { | |
| 21 | + fn to() -> RelationDef { | |
| 22 | + Relation::Operations.def() | |
| 23 | + } | |
| 24 | +} | |
| 25 | + | |
| 26 | +impl Related<super::buffer_snapshot::Entity> for Entity { | |
| 27 | + fn to() -> RelationDef { | |
| 28 | + Relation::Snapshots.def() | |
| 29 | + } | |
| 30 | +} | |
| 31 | + | |
| 32 | +impl ActiveModelBehavior for ActiveModel {} | |
| @@ -0,0 +1,37 @@ | ||
| 1 | +use crate::db::BufferId; | |
| 2 | +use sea_orm::entity::prelude::*; | |
| 3 | + | |
| 4 | +#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)] | |
| 5 | +#[sea_orm(table_name = "buffer_operations")] | |
| 6 | +pub struct Model { | |
| 7 | + #[sea_orm(primary_key)] | |
| 8 | + pub buffer_id: BufferId, | |
| 9 | + #[sea_orm(primary_key)] | |
| 10 | + pub epoch: i32, | |
| 11 | + #[sea_orm(primary_key)] | |
| 12 | + pub lamport_timestamp: i32, | |
| 13 | + #[sea_orm(primary_key)] | |
| 14 | + pub replica_id: i32, | |
| 15 | + pub local_timestamp: i32, | |
| 16 | + pub version: Vec<u8>, | |
| 17 | + pub is_undo: bool, | |
| 18 | + pub value: Vec<u8>, | |
| 19 | +} | |
| 20 | + | |
| 21 | +#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)] | |
| 22 | +pub enum Relation { | |
| 23 | + #[sea_orm( | |
| 24 | + belongs_to = "super::buffer::Entity", | |
| 25 | + from = "Column::BufferId", | |
| 26 | + to = "super::buffer::Column::Id" | |
| 27 | + )] | |
| 28 | + Buffer, | |
| 29 | +} | |
| 30 | + | |
| 31 | +impl Related<super::buffer::Entity> for Entity { | |
| 32 | + fn to() -> RelationDef { | |
| 33 | + Relation::Buffer.def() | |
| 34 | + } | |
| 35 | +} | |
| 36 | + | |
| 37 | +impl ActiveModelBehavior for ActiveModel {} | |
| @@ -0,0 +1,30 @@ | ||
| 1 | +use crate::db::BufferId; | |
| 2 | +use sea_orm::entity::prelude::*; | |
| 3 | + | |
| 4 | +#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)] | |
| 5 | +#[sea_orm(table_name = "buffer_snapshots")] | |
| 6 | +pub struct Model { | |
| 7 | + #[sea_orm(primary_key)] | |
| 8 | + pub buffer_id: BufferId, | |
| 9 | + #[sea_orm(primary_key)] | |
| 10 | + pub epoch: i32, | |
| 11 | + pub text: String, | |
| 12 | +} | |
| 13 | + | |
| 14 | +#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)] | |
| 15 | +pub enum Relation { | |
| 16 | + #[sea_orm( | |
| 17 | + belongs_to = "super::buffer::Entity", | |
| 18 | + from = "Column::BufferId", | |
| 19 | + to = "super::buffer::Column::Id" | |
| 20 | + )] | |
| 21 | + Buffer, | |
| 22 | +} | |
| 23 | + | |
| 24 | +impl Related<super::buffer::Entity> for Entity { | |
| 25 | + fn to() -> RelationDef { | |
| 26 | + Relation::Buffer.def() | |
| 27 | + } | |
| 28 | +} | |
| 29 | + | |
| 30 | +impl ActiveModelBehavior for ActiveModel {} | |
| @@ -96,13 +96,17 @@ macro_rules! test_both_dbs { · 95 unmodified lines | ||
| 96 | 96 | ($test_name:ident, $postgres_test_name:ident, $sqlite_test_name:ident) => { |
| 97 | 97 | #[gpui::test] |
| 98 | 98 | async fn $postgres_test_name() { |
| 99 | − let test_db = TestDb::postgres(Deterministic::new(0).build_background()); | |
| 99 | + let test_db = crate::db::test_db::TestDb::postgres( | |
| 100 | + gpui::executor::Deterministic::new(0).build_background(), | |
| 101 | + ); | |
| 100 | 102 | $test_name(test_db.db()).await; |
| 101 | 103 | } |
| 102 | 104 | |
| 103 | 105 | #[gpui::test] |
| 104 | 106 | async fn $sqlite_test_name() { |
| 105 | − let test_db = TestDb::sqlite(Deterministic::new(0).build_background()); | |
| 107 | + let test_db = crate::db::test_db::TestDb::sqlite( | |
| 108 | + gpui::executor::Deterministic::new(0).build_background(), | |
| 109 | + ); | |
| 106 | 110 | $test_name(test_db.db()).await; |
| 107 | 111 | } |
| 108 | 112 | }; |
| @@ -23,7 +23,7 @@ async-tungstenite = "0.16" · 22 unmodified lines | ||
| 23 | 23 | base64 = "0.13" |
| 24 | 24 | futures.workspace = true |
| 25 | 25 | parking_lot.workspace = true |
| 26 | −prost = "0.8" | |
| 26 | +prost.workspace = true | |
| 27 | 27 | rand.workspace = true |
| 28 | 28 | rsa = "0.4" |
| 29 | 29 | serde.workspace = true |