Mirrored_Repos/AppFlowy
1
0
Fork 0
mirror of https://github.com/AppFlowy-IO/AppFlowy.git synced 2024-08-30 18:12:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: get cell metas

Browse Source
This commit is contained in:
appflowy
2022-04-02 10:54:01 +08:00
parent 82eed0506b
commit 2262dd0d7b
12 changed files with 191 additions and 189 deletions
Download Patch File Download Diff File Expand all files Collapse all files

71
frontend/rust-lib/flowy-grid/src/services/block_meta_editor.rs
View File

@ -1,12 +1,12 @@
use crate::manager::GridUser;
use crate::services::row::{make_cell, make_row_ids_per_block, GridBlockMetaData};
use bytes::Bytes;
use crate::dart_notification::{send_dart_notification, GridNotification};
use crate::manager::GridUser;
use crate::services::row::{make_cell, make_row_ids_per_block, GridBlockSnapshot};
use bytes::Bytes;
use dashmap::DashMap;
use flowy_error::{FlowyError, FlowyResult};
use flowy_grid_data_model::entities::{
FieldMeta, GridBlockMeta, GridBlockMetaChangeset, GridBlockOrder, RepeatedCell, RowMeta, RowMetaChangeset, RowOrder,
CellMeta, FieldMeta, GridBlockMeta, GridBlockMetaChangeset, GridBlockOrder, RepeatedCell, RowMeta,
RowMetaChangeset, RowOrder,
};
use flowy_revision::disk::SQLiteGridBlockMetaRevisionPersistence;
use flowy_revision::{
@ -116,7 +116,8 @@ impl GridBlockMetaEditorManager {
pub async fn get_row(&self, block_id: &str, row_id: &str) -> FlowyResult<Option<Arc<RowMeta>>> {
let editor = self.get_editor(block_id).await?;
let mut row_metas = editor.get_row_metas(Some(vec![row_id.to_owned()])).await?;
let row_ids = vec![row_id.to_owned()];
let mut row_metas = editor.get_row_metas(&Some(row_ids)).await?;
if row_metas.is_empty() {
Ok(None)
} else {
@ -131,42 +132,35 @@ impl GridBlockMetaEditorManager {
Ok(())
}
pub(crate) async fn get_block_meta_data_from_blocks(
&self,
grid_blocks: Vec<GridBlockMeta>,
) -> FlowyResult<Vec<GridBlockMetaData>> {
pub(crate) async fn make_block_snapshots(&self, block_ids: Vec<String>) -> FlowyResult<Vec<GridBlockSnapshot>> {
let mut snapshots = vec![];
for grid_block in grid_blocks {
let editor = self.get_editor(&grid_block.block_id).await?;
let row_metas = editor.get_row_metas(None).await?;
for block_id in block_ids {
let editor = self.get_editor(&block_id).await?;
let row_metas = editor.get_row_metas(&None).await?;
row_metas.iter().for_each(|row_meta| {
self.block_id_by_row_id
.insert(row_meta.id.clone(), row_meta.block_id.clone());
});
snapshots.push(GridBlockMetaData {
block_id: grid_block.block_id,
row_metas,
});
snapshots.push(GridBlockSnapshot { block_id, row_metas });
}
Ok(snapshots)
}
pub(crate) async fn get_block_meta_data(&self, block_ids: &[String]) -> FlowyResult<Vec<GridBlockMetaData>> {
let mut snapshots = vec![];
// Optimization: Using the shared memory(Arc, Cow,etc.) to reduce memory usage.
pub async fn get_cell_metas(
&self,
block_ids: Option<String>,
field_id: &str,
row_ids: Option<Vec<String>>,
) -> FlowyResult<Vec<CellMeta>> {
let mut block_cell_metas = vec![];
for block_id in block_ids {
let editor = self.get_editor(block_id).await?;
let row_metas = editor.get_row_metas(None).await?;
row_metas.iter().for_each(|row_meta| {
self.block_id_by_row_id
.insert(row_meta.id.clone(), row_meta.block_id.clone());
});
snapshots.push(GridBlockMetaData {
block_id: block_id.clone(),
row_metas,
});
let editor = self.get_editor(&block_id).await?;
let cell_metas = editor.get_cell_metas(field_id, &row_ids).await?;
block_cell_metas.extend(cell_metas);
}
Ok(snapshots)
Ok(block_cell_metas)
}
async fn get_editor_from_row_id(&self, row_id: &str) -> FlowyResult<Arc<ClientGridBlockMetaEditor>> {
@ -178,10 +172,7 @@ impl GridBlockMetaEditorManager {
);
Err(FlowyError::internal().context(msg))
}
Some(block_id) => {
let editor = self.get_editor(&block_id).await?;
Ok(editor)
}
Some(block_id) => Ok(self.get_editor(&block_id).await?),
}
}
@ -301,7 +292,8 @@ impl ClientGridBlockMetaEditor {
pub async fn update_row(&self, changeset: RowMetaChangeset) -> FlowyResult<RowMeta> {
let row_id = changeset.row_id.clone();
let _ = self.modify(|pad| Ok(pad.update_row(changeset)?)).await?;
let mut row_metas = self.get_row_metas(Some(vec![row_id.clone()])).await?;
let row_ids = vec![row_id.clone()];
let mut row_metas = self.get_row_metas(&Some(row_ids)).await?;
debug_assert_eq!(row_metas.len(), 1);
if row_metas.is_empty() {
@ -312,12 +304,17 @@ impl ClientGridBlockMetaEditor {
}
}
pub async fn get_row_metas(&self, row_ids: Option<Vec<String>>) -> FlowyResult<Vec<Arc<RowMeta>>> {
pub async fn get_row_metas(&self, row_ids: &Option<Vec<String>>) -> FlowyResult<Vec<Arc<RowMeta>>> {
let row_metas = self.pad.read().await.get_row_metas(row_ids)?;
Ok(row_metas)
}
pub async fn get_row_orders(&self, row_ids: Option<Vec<String>>) -> FlowyResult<Vec<RowOrder>> {
pub async fn get_cell_metas(&self, field_id: &str, row_ids: &Option<Vec<String>>) -> FlowyResult<Vec<CellMeta>> {
let cell_metas = self.pad.read().await.get_cell_metas(field_id, row_ids)?;
Ok(cell_metas)
}
pub async fn get_row_orders(&self, row_ids: &Option<Vec<String>>) -> FlowyResult<Vec<RowOrder>> {
let row_orders = self
.pad
.read()

75
frontend/rust-lib/flowy-grid/src/services/grid_editor.rs
View File

@ -37,8 +37,9 @@ impl ClientGridEditor {
let rev_manager = Arc::new(rev_manager);
let pad = Arc::new(RwLock::new(grid_pad));
let block_meta_manager =
Arc::new(GridBlockMetaEditorManager::new(grid_id, &user, pad.read().await.get_blocks().clone()).await?);
let block_meta_manager = Arc::new(
GridBlockMetaEditorManager::new(grid_id, &user, pad.read().await.get_block_metas().clone()).await?,
);
Ok(Arc::new(Self {
grid_id: grid_id.to_owned(),
@ -113,8 +114,11 @@ impl ClientGridEditor {
}
pub async fn switch_to_field_type(&self, field_id: &str, field_type: &FieldType) -> FlowyResult<()> {
let type_option_json_builder =
|field_type: &FieldType| -> String { default_type_option_builder_from_type(field_type).entry().json_str() };
// let cell_metas = self.block_meta_manager.get_cell_metas(None, field_id, None).await?;
let type_option_json_builder = |field_type: &FieldType| -> String {
return default_type_option_builder_from_type(field_type).entry().json_str();
};
let _ = self
.modify(|grid| Ok(grid.switch_to_field(field_id, field_type.clone(), type_option_json_builder)?))
@ -137,12 +141,12 @@ impl ClientGridEditor {
}
pub async fn create_block(&self, grid_block: GridBlockMeta) -> FlowyResult<()> {
let _ = self.modify(|grid| Ok(grid.create_block(grid_block)?)).await?;
let _ = self.modify(|grid| Ok(grid.create_block_meta(grid_block)?)).await?;
Ok(())
}
pub async fn update_block(&self, changeset: GridBlockMetaChangeset) -> FlowyResult<()> {
let _ = self.modify(|grid| Ok(grid.update_block(changeset)?)).await?;
let _ = self.modify(|grid| Ok(grid.update_block_meta(changeset)?)).await?;
Ok(())
}
@ -192,12 +196,15 @@ impl ClientGridEditor {
pub async fn get_rows(&self, block_id: &str) -> FlowyResult<RepeatedRow> {
let block_ids = vec![block_id.to_owned()];
let mut block_meta_data_vec = self.get_block_meta_data_vec(Some(&block_ids)).await?;
debug_assert_eq!(block_meta_data_vec.len(), 1);
if block_meta_data_vec.len() == 1 {
let block_meta_data = block_meta_data_vec.pop().unwrap();
let mut grid_block_snapshot = self.grid_block_snapshots(Some(block_ids)).await?;
// For the moment, we only support one block.
// We can save the rows into multiple blocks and load them asynchronously in the future.
debug_assert_eq!(grid_block_snapshot.len(), 1);
if grid_block_snapshot.len() == 1 {
let snapshot = grid_block_snapshot.pop().unwrap();
let field_metas = self.get_field_metas(None).await?;
let rows = make_rows_from_row_metas(&field_metas, &block_meta_data.row_metas);
let rows = make_rows_from_row_metas(&field_metas, &snapshot.row_metas);
Ok(rows.into())
} else {
Ok(vec![].into())
@ -240,15 +247,12 @@ impl ClientGridEditor {
}
pub async fn get_blocks(&self, block_ids: Option<Vec<String>>) -> FlowyResult<RepeatedGridBlock> {
let block_meta_data_vec = self.get_block_meta_data_vec(block_ids.as_ref()).await?;
match block_ids {
None => make_grid_blocks(block_meta_data_vec),
Some(block_ids) => make_grid_block_from_block_metas(&block_ids, block_meta_data_vec),
}
let block_snapshots = self.grid_block_snapshots(block_ids.clone()).await?;
make_grid_blocks(block_ids, block_snapshots)
}
pub async fn get_block_metas(&self) -> FlowyResult<Vec<GridBlockMeta>> {
let grid_blocks = self.pad.read().await.get_blocks();
let grid_blocks = self.pad.read().await.get_block_metas();
Ok(grid_blocks)
}
@ -266,7 +270,7 @@ impl ClientGridEditor {
.pad
.read()
.await
.get_blocks()
.get_block_metas()
.into_iter()
.map(|grid_block_meta| GridBlockOrder {
block_id: grid_block_meta.block_id,
@ -285,27 +289,18 @@ impl ClientGridEditor {
Ok(field_metas)
}
pub async fn get_block_meta_data_vec(
&self,
block_ids: Option<&Vec<String>>,
) -> FlowyResult<Vec<GridBlockMetaData>> {
match block_ids {
None => {
let grid_blocks = self.pad.read().await.get_blocks();
let row_metas_per_block = self
.block_meta_manager
.get_block_meta_data_from_blocks(grid_blocks)
.await?;
Ok(row_metas_per_block)
}
Some(block_ids) => {
let row_metas_per_block = self
.block_meta_manager
.get_block_meta_data(block_ids.as_slice())
.await?;
Ok(row_metas_per_block)
}
}
pub async fn grid_block_snapshots(&self, block_ids: Option<Vec<String>>) -> FlowyResult<Vec<GridBlockSnapshot>> {
let block_ids = block_ids.unwrap_or(
self.pad
.read()
.await
.get_block_metas()
.into_iter()
.map(|block_meta| block_meta.block_id)
.collect::<Vec<String>>(),
);
let snapshots = self.block_meta_manager.make_block_snapshots(block_ids).await?;
Ok(snapshots)
}
pub async fn delta_bytes(&self) -> Bytes {
@ -347,7 +342,7 @@ impl ClientGridEditor {
}
async fn block_id(&self) -> FlowyResult<String> {
match self.pad.read().await.get_blocks().last() {
match self.pad.read().await.get_block_metas().last() {
None => Err(FlowyError::internal().context("There is no grid block in this grid")),
Some(grid_block) => Ok(grid_block.block_id.clone()),
}

59
frontend/rust-lib/flowy-grid/src/services/row/row_loader.rs
View File

@ -22,7 +22,7 @@ impl RowIdsPerBlock {
}
}
pub struct GridBlockMetaData {
pub struct GridBlockSnapshot {
pub(crate) block_id: String,
pub row_metas: Vec<Arc<RowMeta>>,
}
@ -40,20 +40,6 @@ pub(crate) fn make_row_ids_per_block(row_orders: &[RowOrder]) -> Vec<RowIdsPerBl
map.into_values().collect::<Vec<_>>()
}
pub(crate) fn make_grid_blocks(block_meta_snapshots: Vec<GridBlockMetaData>) -> FlowyResult<RepeatedGridBlock> {
Ok(block_meta_snapshots
.into_iter()
.map(|block_meta_data| {
let row_orders = make_row_orders_from_row_metas(&block_meta_data.row_metas);
GridBlock {
id: block_meta_data.block_id,
row_orders,
}
})
.collect::<Vec<GridBlock>>()
.into())
}
#[inline(always)]
pub fn make_cell(
field_map: &HashMap<&String, &FieldMeta>,
@ -101,25 +87,36 @@ pub(crate) fn make_rows_from_row_metas(fields: &[FieldMeta], row_metas: &[Arc<Ro
row_metas.iter().map(make_row).collect::<Vec<_>>()
}
pub(crate) fn make_grid_block_from_block_metas(
block_ids: &[String],
block_meta_data_vec: Vec<GridBlockMetaData>,
pub(crate) fn make_grid_blocks(
block_ids: Option<Vec<String>>,
block_snapshots: Vec<GridBlockSnapshot>,
) -> FlowyResult<RepeatedGridBlock> {
let block_meta_data_map: HashMap<&String, &Vec<Arc<RowMeta>>> = block_meta_data_vec
.iter()
.map(|data| (&data.block_id, &data.row_metas))
.collect();
match block_ids {
None => Ok(block_snapshots
.into_iter()
.map(|snapshot| {
let row_orders = make_row_orders_from_row_metas(&snapshot.row_metas);
GridBlock::new(&snapshot.block_id, row_orders)
})
.collect::<Vec<GridBlock>>()
.into()),
Some(block_ids) => {
let block_meta_data_map: HashMap<&String, &Vec<Arc<RowMeta>>> = block_snapshots
.iter()
.map(|data| (&data.block_id, &data.row_metas))
.collect();
let mut grid_blocks = vec![];
for block_id in block_ids {
match block_meta_data_map.get(&block_id) {
None => {}
Some(row_metas) => {
let row_orders = make_row_orders_from_row_metas(row_metas);
grid_blocks.push(GridBlock::new(block_id, row_orders));
let mut grid_blocks = vec![];
for block_id in block_ids {
match block_meta_data_map.get(&block_id) {
None => {}
Some(row_metas) => {
let row_orders = make_row_orders_from_row_metas(row_metas);
grid_blocks.push(GridBlock::new(&block_id, row_orders));
}
}
}
Ok(grid_blocks.into())
}
}
Ok(grid_blocks.into())
}

2
frontend/rust-lib/flowy-grid/tests/grid/script.rs
View File

@ -238,7 +238,7 @@ impl GridEditorTest {
async fn get_row_metas(editor: &Arc<ClientGridEditor>) -> Vec<Arc<RowMeta>> {
editor
.get_block_meta_data_vec(None)
.grid_block_snapshots(None)
.await
.unwrap()
.pop()