@lix-js/sdk 0.6.0-preview.4 → 0.6.0-preview.5

package/dist-engine-src/src/sql2/{entity_history_provider.rs → providers/entity_history.rs}

@@ -22,33 +22,36 @@ use tokio::sync::Mutex;
 
 use crate::commit_graph::CommitGraphReader;
 use crate::serialize_row_metadata;
+use crate::sql2::change_materialization::MaterializedChange;
 use crate::LixError;
 
-use super::entity_provider::{
-    entity_f64_value, entity_i64_value, entity_json_text_value, entity_surface_schema,
-    parse_snapshot, string_array, EntityColumnType, EntityProviderVariant, EntitySurfaceSpec,
+use crate::sql2::catalog::{
+    entity_surface_schema, EntityColumnType, EntitySurfaceShape, EntitySurfaceSpec,
 };
-use super::history_projection::{tombstone_identity_column_value, HistoryIdentityProjection};
-use super::history_route::{
+use crate::sql2::history_projection::{tombstone_identity_column_value, HistoryIdentityProjection};
+use crate::sql2::history_route::{
     load_history_entries, parse_history_filter, HistoryColumnStyle, HistoryRoute,
     HistoryViewDescriptor, HISTORY_COL_START_COMMIT_ID,
 };
-use super::SqlCommitStoreQuerySource;
-use crate::commit_store::MaterializedChange;
+use crate::sql2::providers::entity::{
+    entity_f64_value, entity_i64_value, entity_json_text_value, parse_snapshot, string_array,
+};
+use crate::sql2::SqlHistoryQuerySource;
+use crate::storage::StorageRead;
 
 /// Schema-specific history surface backed directly by the commit graph.
 ///
 /// The provider does not query `lix_state_history` through SQL. It uses the same
 /// commit graph primitive as the generic history surface, then shapes canonical
 /// changes into the typed entity columns for one registered schema.
-pub(crate) struct EntityHistoryProvider {
+pub(crate) struct EntityHistoryProvider<S> {
     spec: Arc<EntitySurfaceSpec>,
     schema: SchemaRef,
     commit_graph: Arc<Mutex<Box<dyn CommitGraphReader>>>,
-    query_source: SqlCommitStoreQuerySource,
+    query_source: SqlHistoryQuerySource<S>,
 }
 
-impl std::fmt::Debug for EntityHistoryProvider {
+impl<S> std::fmt::Debug for EntityHistoryProvider<S> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("EntityHistoryProvider")
             .field("schema_key", &self.spec.schema_key)
@@ -56,14 +59,14 @@ impl std::fmt::Debug for EntityHistoryProvider {
     }
 }
 
-impl EntityHistoryProvider {
+impl<S> EntityHistoryProvider<S> {
     pub(crate) fn new(
         spec: Arc<EntitySurfaceSpec>,
         commit_graph: Arc<Mutex<Box<dyn CommitGraphReader>>>,
-        query_source: SqlCommitStoreQuerySource,
+        query_source: SqlHistoryQuerySource<S>,
     ) -> Self {
         Self {
-            schema: entity_surface_schema(&spec, EntityProviderVariant::History),
+            schema: entity_surface_schema(&spec, EntitySurfaceShape::History),
             spec,
             commit_graph,
             query_source,
@@ -72,7 +75,10 @@ impl EntityHistoryProvider {
 }
 
 #[async_trait]
-impl TableProvider for EntityHistoryProvider {
+impl<S> TableProvider for EntityHistoryProvider<S>
+where
+    S: StorageRead + Clone + Send + Sync + 'static,
+{
     fn as_any(&self) -> &dyn Any {
         self
     }
@@ -121,17 +127,17 @@ impl TableProvider for EntityHistoryProvider {
     }
 }
 
-struct EntityHistoryScanExec {
+struct EntityHistoryScanExec<S> {
     spec: Arc<EntitySurfaceSpec>,
     commit_graph: Arc<Mutex<Box<dyn CommitGraphReader>>>,
-    query_source: SqlCommitStoreQuerySource,
+    query_source: SqlHistoryQuerySource<S>,
     schema: SchemaRef,
     route: HistoryRoute,
     limit: Option<usize>,
     properties: Arc<PlanProperties>,
 }
 
-impl std::fmt::Debug for EntityHistoryScanExec {
+impl<S> std::fmt::Debug for EntityHistoryScanExec<S> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("EntityHistoryScanExec")
             .field("schema_key", &self.spec.schema_key)
@@ -141,11 +147,11 @@ impl std::fmt::Debug for EntityHistoryScanExec {
     }
 }
 
-impl EntityHistoryScanExec {
+impl<S> EntityHistoryScanExec<S> {
     fn new(
         spec: Arc<EntitySurfaceSpec>,
         commit_graph: Arc<Mutex<Box<dyn CommitGraphReader>>>,
-        query_source: SqlCommitStoreQuerySource,
+        query_source: SqlHistoryQuerySource<S>,
         schema: SchemaRef,
         route: HistoryRoute,
         limit: Option<usize>,
@@ -168,7 +174,7 @@ impl EntityHistoryScanExec {
     }
 }
 
-impl DisplayAs for EntityHistoryScanExec {
+impl<S> DisplayAs for EntityHistoryScanExec<S> {
     fn fmt_as(&self, t: DisplayFormatType, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match t {
             DisplayFormatType::Default | DisplayFormatType::Verbose => write!(
@@ -181,7 +187,10 @@ impl DisplayAs for EntityHistoryScanExec {
     }
 }
 
-impl ExecutionPlan for EntityHistoryScanExec {
+impl<S> ExecutionPlan for EntityHistoryScanExec<S>
+where
+    S: StorageRead + Clone + Send + Sync + 'static,
+{
     fn name(&self) -> &str {
         "EntityHistoryScanExec"
     }
@@ -251,13 +260,16 @@ struct EntityHistoryRow {
     depth: u32,
 }
 
-async fn load_entity_history_rows(
+async fn load_entity_history_rows<S>(
     spec: &EntitySurfaceSpec,
     commit_graph: Arc<Mutex<Box<dyn CommitGraphReader>>>,
-    query_source: SqlCommitStoreQuerySource,
+    query_source: SqlHistoryQuerySource<S>,
     route: &HistoryRoute,
     limit: Option<usize>,
-) -> Result<Vec<EntityHistoryRow>, LixError> {
+) -> Result<Vec<EntityHistoryRow>, LixError>
+where
+    S: StorageRead + Clone + Send + Sync + 'static,
+{
     let history_view_name = format!("{}_history", spec.schema_key);
     let entries = load_history_entries(
         HistoryViewDescriptor {
@@ -364,14 +376,14 @@ fn entity_history_column_value(
         return Ok(snapshot.get(column_name).cloned());
     }
 
-    let entity_id = row.change.entity_id.as_json_array_text().map_err(|error| {
+    let entity_pk = row.change.entity_pk.as_json_array_text().map_err(|error| {
         DataFusionError::Execution(format!(
-            "sql2 entity history provider failed to project entity id: {error}"
+            "sql2 entity history provider failed to project entity pk: {error}"
         ))
     })?;
     tombstone_identity_column_value(
         column_name,
-        &entity_id,
+        &entity_pk,
         HistoryIdentityProjection::PrimaryKeyPaths(&spec.primary_key_paths),
     )
     .map_err(|error| DataFusionError::Execution(error.to_string()))
@@ -382,14 +394,14 @@ fn entity_history_system_column_array(
     rows: &[EntityHistoryRow],
 ) -> Result<ArrayRef> {
     Ok(match column_name {
-        "entity_id" => Arc::new(StringArray::from(
+        "entity_pk" => Arc::new(StringArray::from(
             rows.iter()
                 .map(|row| {
                     Some(
                         row.change
-                            .entity_id
+                            .entity_pk
                             .as_json_array_text()
-                            .expect("canonical change entity identity should project"),
+                            .expect("canonical change entity primary key should project"),
                     )
                 })
                 .collect::<Vec<_>>(),
@@ -436,5 +448,5 @@ fn projected_schema(schema: &SchemaRef, projection: Option<&Vec<usize>>) -> Resu
 }
 
 fn lix_error_to_datafusion_error(error: LixError) -> DataFusionError {
-    super::error::lix_error_to_datafusion_error(error)
+    crate::sql2::error::lix_error_to_datafusion_error(error)
 }