node, store: Make catalog::stats a method on Catalog

Author: lutter

node/src/manager/commands/stats.rs

@@ -10,6 +10,7 @@ use diesel::PgConnection;
 use graph::components::store::DeploymentLocator;
 use graph::components::store::VersionStats;
 use graph::prelude::anyhow;
+use graph::prelude::CheapClone as _;
 use graph_store_postgres::command_support::catalog as store_catalog;
 use graph_store_postgres::command_support::catalog::Site;
 use graph_store_postgres::ConnectionPool;
@@ -20,7 +21,7 @@ use graph_store_postgres::PRIMARY_SHARD;
 fn site_and_conn(
     pools: HashMap<Shard, ConnectionPool>,
     search: &DeploymentSearch,
-) -> Result<(Site, PooledConnection<ConnectionManager<PgConnection>>), anyhow::Error> {
+) -> Result<(Arc<Site>, PooledConnection<ConnectionManager<PgConnection>>), anyhow::Error> {
     let primary_pool = pools.get(&*PRIMARY_SHARD).unwrap();
     let locator = search.locate_unique(primary_pool)?;
 
@@ -30,6 +31,7 @@ fn site_and_conn(
     let site = conn
         .locate_site(locator)?
         .ok_or_else(|| anyhow!("deployment `{}` does not exist", search))?;
+    let site = Arc::new(site);
 
     let conn = pools.get(&site.shard).unwrap().get()?;
 
@@ -96,7 +98,8 @@ pub fn show(
 ) -> Result<(), anyhow::Error> {
     let (site, mut conn) = site_and_conn(pools, search)?;
 
-    let stats = store_catalog::stats(&mut conn, &site)?;
+    let catalog = store_catalog::Catalog::load(&mut conn, site.cheap_clone(), false, vec![])?;
+    let stats = catalog.stats(&mut conn)?;
 
     let account_like = store_catalog::account_like(&mut conn, &site)?;
 

store/postgres/src/catalog.rs

@@ -269,6 +269,70 @@ impl Catalog {
             MINMAX_OPS
         }
     }
+
+    pub fn stats(&self, conn: &mut PgConnection) -> Result<Vec<VersionStats>, StoreError> {
+        #[derive(Queryable, QueryableByName)]
+        pub struct DbStats {
+            #[diesel(sql_type = BigInt)]
+            pub entities: i64,
+            #[diesel(sql_type = BigInt)]
+            pub versions: i64,
+            #[diesel(sql_type = Text)]
+            pub tablename: String,
+            /// The ratio `entities / versions`
+            #[diesel(sql_type = Double)]
+            pub ratio: f64,
+            #[diesel(sql_type = Nullable<Integer>)]
+            pub last_pruned_block: Option<i32>,
+        }
+
+        impl From<DbStats> for VersionStats {
+            fn from(s: DbStats) -> Self {
+                VersionStats {
+                    entities: s.entities,
+                    versions: s.versions,
+                    tablename: s.tablename,
+                    ratio: s.ratio,
+                    last_pruned_block: s.last_pruned_block,
+                }
+            }
+        }
+
+        // Get an estimate of number of rows (pg_class.reltuples) and number of
+        // distinct entities (based on the planners idea of how many distinct
+        // values there are in the `id` column) See the [Postgres
+        // docs](https://www.postgresql.org/docs/current/view-pg-stats.html) for
+        // the precise meaning of n_distinct
+        let query = "select case when s.n_distinct < 0 then (- s.n_distinct * c.reltuples)::int8
+                     else s.n_distinct::int8
+                 end as entities,
+                 c.reltuples::int8 as versions,
+                 c.relname as tablename,
+                case when c.reltuples = 0 then 0::float8
+                     when s.n_distinct < 0 then (-s.n_distinct)::float8
+                     else greatest(s.n_distinct, 1)::float8 / c.reltuples::float8
+                 end as ratio,
+                 ts.last_pruned_block
+           from pg_namespace n, pg_class c, pg_stats s
+                left outer join subgraphs.table_stats ts
+                     on (ts.table_name = s.tablename
+                     and ts.deployment = $1)
+          where n.nspname = $2
+            and c.relnamespace = n.oid
+            and s.schemaname = n.nspname
+            and s.attname = 'id'
+            and c.relname = s.tablename
+          order by c.relname"
+            .to_string();
+
+        let stats = sql_query(query)
+            .bind::<Integer, _>(self.site.id)
+            .bind::<Text, _>(self.site.namespace.as_str())
+            .load::<DbStats>(conn)
+            .map_err(StoreError::from)?;
+
+        Ok(stats.into_iter().map(|s| s.into()).collect())
+    }
 }
 
 fn get_text_columns(
@@ -764,70 +828,6 @@ pub(crate) fn drop_index(
     Ok(())
 }
 
-pub fn stats(conn: &mut PgConnection, site: &Site) -> Result<Vec<VersionStats>, StoreError> {
-    #[derive(Queryable, QueryableByName)]
-    pub struct DbStats {
-        #[diesel(sql_type = BigInt)]
-        pub entities: i64,
-        #[diesel(sql_type = BigInt)]
-        pub versions: i64,
-        #[diesel(sql_type = Text)]
-        pub tablename: String,
-        /// The ratio `entities / versions`
-        #[diesel(sql_type = Double)]
-        pub ratio: f64,
-        #[diesel(sql_type = Nullable<Integer>)]
-        pub last_pruned_block: Option<i32>,
-    }
-
-    impl From<DbStats> for VersionStats {
-        fn from(s: DbStats) -> Self {
-            VersionStats {
-                entities: s.entities,
-                versions: s.versions,
-                tablename: s.tablename,
-                ratio: s.ratio,
-                last_pruned_block: s.last_pruned_block,
-            }
-        }
-    }
-
-    // Get an estimate of number of rows (pg_class.reltuples) and number of
-    // distinct entities (based on the planners idea of how many distinct
-    // values there are in the `id` column) See the [Postgres
-    // docs](https://www.postgresql.org/docs/current/view-pg-stats.html) for
-    // the precise meaning of n_distinct
-    let query = "select case when s.n_distinct < 0 then (- s.n_distinct * c.reltuples)::int8
-                     else s.n_distinct::int8
-                 end as entities,
-                 c.reltuples::int8 as versions,
-                 c.relname as tablename,
-                case when c.reltuples = 0 then 0::float8
-                     when s.n_distinct < 0 then (-s.n_distinct)::float8
-                     else greatest(s.n_distinct, 1)::float8 / c.reltuples::float8
-                 end as ratio,
-                 ts.last_pruned_block
-           from pg_namespace n, pg_class c, pg_stats s
-                left outer join subgraphs.table_stats ts
-                     on (ts.table_name = s.tablename
-                     and ts.deployment = $1)
-          where n.nspname = $2
-            and c.relnamespace = n.oid
-            and s.schemaname = n.nspname
-            and s.attname = 'id'
-            and c.relname = s.tablename
-          order by c.relname"
-        .to_string();
-
-    let stats = sql_query(query)
-        .bind::<Integer, _>(site.id)
-        .bind::<Text, _>(site.namespace.as_str())
-        .load::<DbStats>(conn)
-        .map_err(StoreError::from)?;
-
-    Ok(stats.into_iter().map(|s| s.into()).collect())
-}
-
 /// Return by how much the slowest replica connected to the database `conn`
 /// is lagging. The returned value has millisecond precision. If the
 /// database has no replicas, return `0`

store/postgres/src/lib.rs

@@ -73,7 +73,7 @@ pub use self::subgraph_store::{unused, DeploymentPlacer, Shard, SubgraphStore, P
 pub mod command_support {
     pub mod catalog {
         pub use crate::block_store::primary as block_store;
-        pub use crate::catalog::{account_like, stats};
+        pub use crate::catalog::{account_like, Catalog};
         pub use crate::copy::{copy_state, copy_table_state};
         pub use crate::primary::{
             active_copies, deployment_schemas, ens_names, subgraph, subgraph_deployment_assignment,

store/postgres/src/relational/prune.rs

@@ -267,7 +267,7 @@ impl Layout {
             reporter.finish_analyze_table(table.name.as_str());
             cancel.check_cancel()?;
         }
-        let stats = catalog::stats(conn, &self.site)?;
+        let stats = self.catalog.stats(conn)?;
 
         let analyzed: Vec<_> = tables.iter().map(|table| table.name.as_str()).collect();
         reporter.finish_analyze(&stats, &analyzed);