store: Move has_causality_region to manifest, rename to `entities_w…

…ith_causality_region`

core/src/subgraph/registrar.rs

@@ -642,7 +642,7 @@ async fn create_subgraph_version<C: Blockchain, S: SubgraphStore>(
     let deployment = DeploymentCreate::new(raw_string, &manifest, start_block)
         .graft(base_block)
         .debug(debug_fork)
-        .has_causality_region(needs_causality_region);
+        .entities_with_causality_region(needs_causality_region);
 
     deployment_store
         .create_subgraph_deployment(

graph/src/data/subgraph/schema.rs

@@ -107,7 +107,6 @@ pub struct DeploymentCreate {
     pub graft_base: Option<DeploymentHash>,
     pub graft_block: Option<BlockPtr>,
     pub debug_fork: Option<DeploymentHash>,
-    pub has_causality_region: BTreeSet<EntityType>,
 }
 
 impl DeploymentCreate {
@@ -117,12 +116,11 @@ impl DeploymentCreate {
         start_block: Option<BlockPtr>,
     ) -> Self {
         Self {
-            manifest: SubgraphManifestEntity::new(raw_manifest, source_manifest),
+            manifest: SubgraphManifestEntity::new(raw_manifest, source_manifest, Vec::new()),
             start_block: start_block.cheap_clone(),
             graft_base: None,
             graft_block: None,
             debug_fork: None,
-            has_causality_region: BTreeSet::new(),
         }
     }
 
@@ -139,8 +137,12 @@ impl DeploymentCreate {
         self
     }
 
-    pub fn has_causality_region(mut self, has_causality_region: BTreeSet<EntityType>) -> Self {
-        self.has_causality_region = has_causality_region;
+    pub fn entities_with_causality_region(
+        mut self,
+        entities_with_causality_region: BTreeSet<EntityType>,
+    ) -> Self {
+        self.manifest.entities_with_causality_region =
+            entities_with_causality_region.into_iter().collect();
         self
     }
 }
@@ -166,7 +168,6 @@ pub struct SubgraphDeploymentEntity {
     pub reorg_count: i32,
     pub current_reorg_depth: i32,
     pub max_reorg_depth: i32,
-    pub has_causality_region: Vec<EntityType>,
 }
 
 #[derive(Debug)]
@@ -177,17 +178,23 @@ pub struct SubgraphManifestEntity {
     pub features: Vec<String>,
     pub schema: String,
     pub raw_yaml: Option<String>,
+    pub entities_with_causality_region: Vec<EntityType>,
 }
 
 impl SubgraphManifestEntity {
-    pub fn new(raw_yaml: String, manifest: &super::SubgraphManifest<impl Blockchain>) -> Self {
+    pub fn new(
+        raw_yaml: String,
+        manifest: &super::SubgraphManifest<impl Blockchain>,
+        entities_with_causality_region: Vec<EntityType>,
+    ) -> Self {
         Self {
             spec_version: manifest.spec_version.to_string(),
             description: manifest.description.clone(),
             repository: manifest.repository.clone(),
             features: manifest.features.iter().map(|f| f.to_string()).collect(),
             schema: manifest.schema.document.clone().to_string(),
             raw_yaml: Some(raw_yaml),
+            entities_with_causality_region,
         }
     }
 

store/postgres/migrations/2022-11-10-185105_add_has_causality_region_column/down.sql

@@ -1 +1 @@
-alter table subgraphs.subgraph_deployment drop column has_causality_region;
+alter table subgraphs.subgraph_manifest drop column entities_with_causality_region;

store/postgres/migrations/2022-11-10-185105_add_has_causality_region_column/up.sql

@@ -1 +1 @@
-alter table subgraphs.subgraph_deployment add column has_causality_region text[] not null default array[]::text[];
+alter table subgraphs.subgraph_manifest add column entities_with_causality_region text[] not null default array[]::text[];

store/postgres/src/catalog.rs

@@ -186,7 +186,7 @@ pub struct Catalog {
     pub use_bytea_prefix: bool,
 
     /// Set of tables which have an explicit causality region column.
-    pub(crate) has_causality_region: BTreeSet<EntityType>,
+    pub(crate) entities_with_causality_region: BTreeSet<EntityType>,
 }
 
 impl Catalog {
@@ -195,7 +195,7 @@ impl Catalog {
         conn: &PgConnection,
         site: Arc<Site>,
         use_bytea_prefix: bool,
-        has_causality_region: Vec<EntityType>,
+        entities_with_causality_region: Vec<EntityType>,
     ) -> Result<Self, StoreError> {
         let text_columns = get_text_columns(conn, &site.namespace)?;
         let use_poi = supports_proof_of_indexing(conn, &site.namespace)?;
@@ -204,12 +204,15 @@ impl Catalog {
             text_columns,
             use_poi,
             use_bytea_prefix,
-            has_causality_region: has_causality_region.into_iter().collect(),
+            entities_with_causality_region: entities_with_causality_region.into_iter().collect(),
         })
     }
 
     /// Return a new catalog suitable for creating a new subgraph
-    pub fn for_creation(site: Arc<Site>, has_causality_region: BTreeSet<EntityType>) -> Self {
+    pub fn for_creation(
+        site: Arc<Site>,
+        entities_with_causality_region: BTreeSet<EntityType>,
+    ) -> Self {
         Catalog {
             site,
             text_columns: HashMap::default(),
@@ -218,7 +221,7 @@ impl Catalog {
             // DDL generation creates indexes for prefixes of bytes columns
             // see: attr-bytea-prefix
             use_bytea_prefix: true,
-            has_causality_region,
+            entities_with_causality_region,
         }
     }
 
@@ -227,14 +230,14 @@ impl Catalog {
     /// connection is definitely not available, such as in unit tests
     pub fn for_tests(
         site: Arc<Site>,
-        has_causality_region: BTreeSet<EntityType>,
+        entities_with_causality_region: BTreeSet<EntityType>,
     ) -> Result<Self, StoreError> {
         Ok(Catalog {
             site,
             text_columns: HashMap::default(),
             use_poi: false,
             use_bytea_prefix: true,
-            has_causality_region,
+            entities_with_causality_region,
         })
     }
 

store/postgres/src/deployment.rs

@@ -87,10 +87,6 @@ table! {
         current_reorg_depth -> Integer,
         max_reorg_depth -> Integer,
         firehose_cursor -> Nullable<Text>,
-
-        // Entity types that have a `causality_region` column.
-        // Names stored as present in the schema, not in snake case.
-        has_causality_region -> Array<Text>,
     }
 }
 
@@ -121,6 +117,10 @@ table! {
         start_block_number -> Nullable<Integer>,
         start_block_hash -> Nullable<Binary>,
         raw_yaml -> Nullable<Text>,
+
+        // Entity types that have a `causality_region` column.
+        // Names stored as present in the schema, not in snake case.
+        entities_with_causality_region -> Array<Text>,
     }
 }
 
@@ -776,15 +776,15 @@ pub(crate) fn health(conn: &PgConnection, id: DeploymentId) -> Result<SubgraphHe
         .map_err(|e| e.into())
 }
 
-pub(crate) fn has_causality_region(
+pub(crate) fn entities_with_causality_region(
     conn: &PgConnection,
     id: DeploymentId,
 ) -> Result<Vec<EntityType>, StoreError> {
-    use subgraph_deployment as d;
+    use subgraph_manifest as sm;
 
-    d::table
-        .filter(d::id.eq(id))
-        .select(d::has_causality_region)
+    sm::table
+        .filter(sm::id.eq(id))
+        .select(sm::entities_with_causality_region)
         .get_result(conn)
         .map_err(|e| e.into())
 }
@@ -931,15 +931,15 @@ pub fn create_deployment(
                 features,
                 schema,
                 raw_yaml,
+                entities_with_causality_region,
             },
         start_block,
         graft_base,
         graft_block,
         debug_fork,
-        has_causality_region,
     } = deployment;
     let earliest_block_number = start_block.as_ref().map(|ptr| ptr.number).unwrap_or(0);
-    let has_causality_region = Vec::from_iter(has_causality_region.into_iter());
+    let entities_with_causality_region = Vec::from_iter(entities_with_causality_region.into_iter());
 
     let deployment_values = (
         d::id.eq(site.id),
@@ -957,7 +957,6 @@ pub fn create_deployment(
         d::graft_block_hash.eq(b(&graft_block)),
         d::graft_block_number.eq(n(&graft_block)),
         d::debug_fork.eq(debug_fork.as_ref().map(|s| s.as_str())),
-        d::has_causality_region.eq(has_causality_region),
     );
 
     let graph_node_version_id = GraphNodeVersion::create_or_get(conn)?;
@@ -976,6 +975,7 @@ pub fn create_deployment(
         m::start_block_hash.eq(b(&start_block)),
         m::start_block_number.eq(start_block.as_ref().map(|ptr| ptr.number)),
         m::raw_yaml.eq(raw_yaml),
+        m::entities_with_causality_region.eq(entities_with_causality_region),
     );
 
     if exists && replace {

store/postgres/src/deployment_store.rs

@@ -174,7 +174,8 @@ impl DeploymentStore {
             let exists = deployment::exists(&conn, &site)?;
 
             // Create (or update) the metadata. Update only happens in tests
-            let has_causality_region = deployment.has_causality_region.clone();
+            let entities_with_causality_region =
+                deployment.manifest.entities_with_causality_region.clone();
             if replace || !exists {
                 deployment::create_deployment(&conn, &site, deployment, exists, replace)?;
             };
@@ -188,7 +189,7 @@ impl DeploymentStore {
                     &conn,
                     site.clone(),
                     schema,
-                    has_causality_region,
+                    entities_with_causality_region.into_iter().collect(),
                 )?;
                 // See if we are grafting and check that the graft is permissible
                 if let Some(base) = graft_base {

store/postgres/src/detail.rs

@@ -65,7 +65,6 @@ pub struct DeploymentDetail {
     current_reorg_depth: i32,
     max_reorg_depth: i32,
     firehose_cursor: Option<String>,
-    has_causality_region: Vec<EntityType>,
 }
 
 #[derive(Queryable, QueryableByName)]
@@ -340,6 +339,7 @@ struct StoredSubgraphManifest {
     start_block_number: Option<i32>,
     start_block_hash: Option<Bytes>,
     raw_yaml: Option<String>,
+    entities_with_causality_region: Vec<EntityType>,
 }
 
 impl From<StoredSubgraphManifest> for SubgraphManifestEntity {
@@ -351,6 +351,7 @@ impl From<StoredSubgraphManifest> for SubgraphManifestEntity {
             features: value.features,
             schema: value.schema,
             raw_yaml: value.raw_yaml,
+            entities_with_causality_region: value.entities_with_causality_region,
         }
     }
 }
@@ -415,7 +416,6 @@ impl TryFrom<StoredDeploymentEntity> for SubgraphDeploymentEntity {
             reorg_count: detail.reorg_count,
             current_reorg_depth: detail.current_reorg_depth,
             max_reorg_depth: detail.max_reorg_depth,
-            has_causality_region: detail.has_causality_region,
         })
     }
 }

store/postgres/src/relational.rs

@@ -315,7 +315,7 @@ impl Layout {
                     &id_types,
                     i as u32,
                     catalog
-                        .has_causality_region
+                        .entities_with_causality_region
                         .contains(&EntityType::from(obj_type.clone())),
                 )
             })
@@ -409,9 +409,9 @@ impl Layout {
         conn: &PgConnection,
         site: Arc<Site>,
         schema: &Schema,
-        has_causality_region: BTreeSet<EntityType>,
+        entities_with_causality_region: BTreeSet<EntityType>,
     ) -> Result<Layout, StoreError> {
-        let catalog = Catalog::for_creation(site.cheap_clone(), has_causality_region);
+        let catalog = Catalog::for_creation(site.cheap_clone(), entities_with_causality_region);
         let layout = Self::new(site, schema, catalog)?;
         let sql = layout
             .as_ddl()
@@ -1389,7 +1389,7 @@ impl LayoutCache {
 
     fn load(conn: &PgConnection, site: Arc<Site>) -> Result<Arc<Layout>, StoreError> {
         let (subgraph_schema, use_bytea_prefix) = deployment::schema(conn, site.as_ref())?;
-        let has_causality_region = deployment::has_causality_region(conn, site.id)?;
+        let has_causality_region = deployment::entities_with_causality_region(conn, site.id)?;
         let catalog = Catalog::load(conn, site.clone(), use_bytea_prefix, has_causality_region)?;
         let layout = Arc::new(Layout::new(site.clone(), &subgraph_schema, catalog)?);
         layout.refresh(conn, site)

store/postgres/src/subgraph_store.rs

@@ -627,7 +627,6 @@ impl SubgraphStoreInner {
             graft_base: Some(src.deployment.clone()),
             graft_block: Some(block),
             debug_fork: deployment.debug_fork,
-            has_causality_region: deployment.has_causality_region.into_iter().collect(),
         };
 
         let graft_base = self.layout(&src.deployment)?;