From 5085e0461d3884cbe223178b4f669e410d0d73a2 Mon Sep 17 00:00:00 2001 From: pawurb Date: Tue, 23 Jan 2024 22:28:32 +0100 Subject: [PATCH] Use enum for query files --- src/lib.rs | 177 ++++++++++++++++++++++++++++++++--------------------- 1 file changed, 108 insertions(+), 69 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 17abeeb..b0fc0c0 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -52,63 +52,63 @@ pub fn render_table(items: Vec) { } pub fn bloat() -> Result, PgExtrasError> { - let query = read_file(Bloat::FILE_NAME); + let query = Query::read_file(Query::Bloat); Ok(get_rows(query)?.iter().map(Bloat::new).collect()) } pub fn blocking(limit: Option) -> Result, PgExtrasError> { let limit = limit.unwrap_or("10".to_string()); - let query = read_file(Blocking::FILE_NAME).replace("%{limit}", limit.as_str()); + let query = Query::read_file(Query::Blocking).replace("%{limit}", limit.as_str()); Ok(get_rows(&query)?.iter().map(Blocking::new).collect()) } pub fn calls(limit: Option) -> Result, PgExtrasError> { let limit = limit.unwrap_or("10".to_string()); - let query = read_file("calls").replace("%{limit}", limit.as_str()); + let query = Query::read_file(Query::Calls).replace("%{limit}", limit.as_str()); Ok(get_rows(&query)?.iter().map(Calls::new).collect()) } pub fn extensions() -> Result, PgExtrasError> { - let query = read_file(Extensions::FILE_NAME); + let query = Query::read_file(Query::Extensions); Ok(get_rows(query)?.iter().map(Extensions::new).collect()) } pub fn table_cache_hit() -> Result, PgExtrasError> { - let query = read_file(TableCacheHit::FILE_NAME); + let query = Query::read_file(Query::TableCacheHit); Ok(get_rows(query)?.iter().map(TableCacheHit::new).collect()) } pub fn tables(schema: Option) -> Result, PgExtrasError> { let schema_name = schema.unwrap_or(get_default_schema()); - let query = read_file(Tables::FILE_NAME).replace("%{schema}", &schema_name); + let query = Query::read_file(Query::Tables).replace("%{schema}", &schema_name); Ok(get_rows(&query)?.iter().map(Tables::new).collect()) } pub fn index_cache_hit(schema: Option) -> Result, PgExtrasError> { let schema_name = schema.unwrap_or(get_default_schema()); - let query = read_file(IndexCacheHit::FILE_NAME).replace("%{schema}", &schema_name); + let query = Query::read_file(Query::IndexCacheHit).replace("%{schema}", &schema_name); Ok(get_rows(&query)?.iter().map(IndexCacheHit::new).collect()) } pub fn indexes() -> Result, PgExtrasError> { - let query = read_file(Indexes::FILE_NAME); + let query = Query::read_file(Query::Indexes); Ok(get_rows(query)?.iter().map(Indexes::new).collect()) } pub fn index_size() -> Result, PgExtrasError> { - let query = read_file(IndexSize::FILE_NAME); + let query = Query::read_file(Query::IndexSize); Ok(get_rows(query)?.iter().map(IndexSize::new).collect()) } pub fn index_usage(schema: Option) -> Result, PgExtrasError> { let schema_name = schema.unwrap_or(get_default_schema()); - let query = read_file(IndexUsage::FILE_NAME).replace("%{schema}", &schema_name); + let query = Query::read_file(Query::IndexUsage).replace("%{schema}", &schema_name); Ok(get_rows(&query)?.iter().map(IndexUsage::new).collect()) } pub fn index_scans(schema: Option) -> Result, PgExtrasError> { let schema_name = schema.unwrap_or(get_default_schema()); - let query = read_file(IndexScans::FILE_NAME).replace("%{schema}", &schema_name); + let query = Query::read_file(Query::IndexScans).replace("%{schema}", &schema_name); Ok(get_rows(&query)?.iter().map(IndexScans::new).collect()) } @@ -116,23 +116,23 @@ pub fn null_indexes( min_relation_size_mb: Option, ) -> Result, PgExtrasError> { let min_relation_size_mb = min_relation_size_mb.unwrap_or("0".to_string()); - let query = - read_file(NullIndexes::FILE_NAME).replace("%{min_relation_size_mb}", &min_relation_size_mb); + let query = Query::read_file(Query::NullIndexes) + .replace("%{min_relation_size_mb}", &min_relation_size_mb); Ok(get_rows(&query)?.iter().map(NullIndexes::new).collect()) } pub fn locks() -> Result, PgExtrasError> { - let query = read_file(Locks::FILE_NAME); + let query = Query::read_file(Query::Locks); Ok(get_rows(query)?.iter().map(Locks::new).collect()) } pub fn all_locks() -> Result, PgExtrasError> { - let query = read_file(AllLocks::FILE_NAME); + let query = Query::read_file(Query::AllLocks); Ok(get_rows(query)?.iter().map(AllLocks::new).collect()) } pub fn long_running_queries() -> Result, PgExtrasError> { - let query = read_file(LongRunningQueries::FILE_NAME); + let query = Query::read_file(Query::LongRunningQueries); Ok(get_rows(query)? .iter() .map(LongRunningQueries::new) @@ -140,36 +140,37 @@ pub fn long_running_queries() -> Result, PgExtrasError> } pub fn mandelbrot() -> Result, PgExtrasError> { - let query = read_file(Mandelbrot::FILE_NAME); + let query = Query::read_file(Query::Mandelbrot); Ok(get_rows(query)?.iter().map(Mandelbrot::new).collect()) } pub fn outliers() -> Result, PgExtrasError> { - let query = read_file(Outliers::FILE_NAME); + let query = Query::read_file(Query::Outliers); Ok(get_rows(query)?.iter().map(Outliers::new).collect()) } pub fn records_rank(schema: Option) -> Result, PgExtrasError> { let schema_name = schema.unwrap_or(get_default_schema()); - let query = read_file(RecordsRank::FILE_NAME).replace("%{schema}", schema_name.as_str()); + let query = Query::read_file(Query::RecordsRank).replace("%{schema}", schema_name.as_str()); Ok(get_rows(&query)?.iter().map(RecordsRank::new).collect()) } pub fn seq_scans(schema: Option) -> Result, PgExtrasError> { let schema_name = schema.unwrap_or(get_default_schema()); - let query = read_file(SeqScans::FILE_NAME).replace("%{schema}", schema_name.as_str()); + let query = Query::read_file(Query::SeqScans).replace("%{schema}", schema_name.as_str()); Ok(get_rows(&query)?.iter().map(SeqScans::new).collect()) } pub fn table_index_scans(schema: Option) -> Result, PgExtrasError> { let schema_name = schema.unwrap_or(get_default_schema()); - let query = read_file(TableIndexScans::FILE_NAME).replace("%{schema}", schema_name.as_str()); + let query = Query::read_file(Query::TableIndexScans).replace("%{schema}", schema_name.as_str()); Ok(get_rows(&query)?.iter().map(TableIndexScans::new).collect()) } pub fn table_indexes_size(schema: Option) -> Result, PgExtrasError> { let schema_name = schema.unwrap_or(get_default_schema()); - let query = read_file(TableIndexesSize::FILE_NAME).replace("%{schema}", schema_name.as_str()); + let query = + Query::read_file(Query::TableIndexesSize).replace("%{schema}", schema_name.as_str()); Ok(get_rows(&query)? .iter() .map(TableIndexesSize::new) @@ -177,102 +178,140 @@ pub fn table_indexes_size(schema: Option) -> Result Result, PgExtrasError> { - let query = read_file(TableSize::FILE_NAME); + let query = Query::read_file(Query::TableSize); Ok(get_rows(query)?.iter().map(TableSize::new).collect()) } pub fn total_index_size() -> Result, PgExtrasError> { - let query = read_file(TotalIndexSize::FILE_NAME); + let query = Query::read_file(Query::TotalIndexSize); Ok(get_rows(query)?.iter().map(TotalIndexSize::new).collect()) } pub fn total_table_size() -> Result, PgExtrasError> { - let query = read_file(TotalTableSize::FILE_NAME); + let query = Query::read_file(Query::TotalTableSize); Ok(get_rows(query)?.iter().map(TotalTableSize::new).collect()) } pub fn unused_indexes(schema: Option) -> Result, PgExtrasError> { let schema_name = schema.unwrap_or(get_default_schema()); - let query = read_file(UnusedIndexes::FILE_NAME).replace("%{schema}", schema_name.as_str()); + let query = Query::read_file(Query::UnusedIndexes).replace("%{schema}", schema_name.as_str()); Ok(get_rows(&query)?.iter().map(UnusedIndexes::new).collect()) } pub fn duplicate_indexes() -> Result, PgExtrasError> { - let query = read_file(DuplicateIndexes::FILE_NAME); + let query = Query::read_file(Query::DuplicateIndexes); Ok(get_rows(query)?.iter().map(DuplicateIndexes::new).collect()) } pub fn vacuum_stats() -> Result, PgExtrasError> { - let query = read_file(VacuumStats::FILE_NAME); + let query = Query::read_file(Query::VacuumStats); Ok(get_rows(query)?.iter().map(VacuumStats::new).collect()) } pub fn buffercache_stats() -> Result, PgExtrasError> { - let query = read_file(BuffercacheStats::FILE_NAME); + let query = Query::read_file(Query::BuffercacheStats); Ok(get_rows(query)?.iter().map(BuffercacheStats::new).collect()) } pub fn buffercache_usage() -> Result, PgExtrasError> { - let query = read_file(BuffercacheUsage::FILE_NAME); + let query = Query::read_file(Query::BuffercacheUsage); Ok(get_rows(query)?.iter().map(BuffercacheUsage::new).collect()) } pub fn ssl_used() -> Result, PgExtrasError> { - let query = read_file(SslUsed::FILE_NAME); + let query = Query::read_file(Query::SslUsed); Ok(get_rows(query)?.iter().map(SslUsed::new).collect()) } pub fn connections() -> Result, PgExtrasError> { - let query = read_file(Connections::FILE_NAME); + let query = Query::read_file(Query::Connections); Ok(get_rows(query)?.iter().map(Connections::new).collect()) } pub fn cache_hit(schema: Option) -> Result, PgExtrasError> { let schema_name = schema.unwrap_or(get_default_schema()); - let query = read_file(CacheHit::FILE_NAME).replace("%{schema}", schema_name.as_str()); + let query = Query::read_file(Query::CacheHit).replace("%{schema}", schema_name.as_str()); Ok(get_rows(&query)?.iter().map(CacheHit::new).collect()) } pub fn db_settings() -> Result, PgExtrasError> { - let query = read_file("db_settings"); + let query = Query::read_file(Query::DbSettings); Ok(get_rows(query)?.iter().map(DbSetting::new).collect()) } -pub fn read_file(filename: &str) -> &'static str { - match filename { - "cache_hit" => include_str!("queries/cache_hit.sql"), - "bloat" => include_str!("queries/bloat.sql"), - "blocking" => include_str!("queries/blocking.sql"), - "calls" => include_str!("queries/calls.sql"), - "extensions" => include_str!("queries/extensions.sql"), - "table_cache_hit" => include_str!("queries/table_cache_hit.sql"), - "tables" => include_str!("queries/tables.sql"), - "index_cache_hit" => include_str!("queries/index_cache_hit.sql"), - "indexes" => include_str!("queries/indexes.sql"), - "index_size" => include_str!("queries/index_size.sql"), - "index_usage" => include_str!("queries/index_usage.sql"), - "index_scans" => include_str!("queries/index_scans.sql"), - "null_indexes" => include_str!("queries/null_indexes.sql"), - "locks" => include_str!("queries/locks.sql"), - "all_locks" => include_str!("queries/all_locks.sql"), - "long_running_queries" => include_str!("queries/long_running_queries.sql"), - "mandelbrot" => include_str!("queries/mandelbrot.sql"), - "outliers" => include_str!("queries/outliers.sql"), - "records_rank" => include_str!("queries/records_rank.sql"), - "seq_scans" => include_str!("queries/seq_scans.sql"), - "table_index_scans" => include_str!("queries/table_index_scans.sql"), - "table_indexes_size" => include_str!("queries/table_indexes_size.sql"), - "table_size" => include_str!("queries/table_size.sql"), - "total_index_size" => include_str!("queries/total_index_size.sql"), - "total_table_size" => include_str!("queries/total_table_size.sql"), - "unused_indexes" => include_str!("queries/unused_indexes.sql"), - "duplicate_indexes" => include_str!("queries/duplicate_indexes.sql"), - "vacuum_stats" => include_str!("queries/vacuum_stats.sql"), - "buffercache_stats" => include_str!("queries/buffercache_stats.sql"), - "buffercache_usage" => include_str!("queries/buffercache_usage.sql"), - "ssl_used" => include_str!("queries/ssl_used.sql"), - "connections" => include_str!("queries/connections.sql"), - _ => panic!("Unknown file: {}", filename), +enum Query { + CacheHit, + Bloat, + Blocking, + Calls, + Extensions, + TableCacheHit, + Tables, + IndexCacheHit, + DbSettings, + Indexes, + IndexSize, + IndexUsage, + IndexScans, + NullIndexes, + Locks, + AllLocks, + LongRunningQueries, + Mandelbrot, + Outliers, + RecordsRank, + SeqScans, + TableIndexScans, + TableIndexesSize, + TableSize, + TotalIndexSize, + TotalTableSize, + UnusedIndexes, + DuplicateIndexes, + VacuumStats, + BuffercacheStats, + BuffercacheUsage, + SslUsed, + Connections, +} + +impl Query { + pub fn read_file(query: Query) -> &'static str { + match query { + Query::CacheHit => include_str!("queries/cache_hit.sql"), + Query::DbSettings => include_str!("queries/db_settings.sql"), + Query::BuffercacheStats => include_str!("queries/buffercache_stats.sql"), + Query::BuffercacheUsage => include_str!("queries/buffercache_usage.sql"), + Query::SslUsed => include_str!("queries/ssl_used.sql"), + Query::Connections => include_str!("queries/connections.sql"), + Query::Bloat => include_str!("queries/bloat.sql"), + Query::Blocking => include_str!("queries/blocking.sql"), + Query::Calls => include_str!("queries/calls.sql"), + Query::Extensions => include_str!("queries/extensions.sql"), + Query::TableCacheHit => include_str!("queries/table_cache_hit.sql"), + Query::Tables => include_str!("queries/tables.sql"), + Query::IndexCacheHit => include_str!("queries/index_cache_hit.sql"), + Query::Indexes => include_str!("queries/indexes.sql"), + Query::IndexSize => include_str!("queries/index_size.sql"), + Query::IndexUsage => include_str!("queries/index_usage.sql"), + Query::IndexScans => include_str!("queries/index_scans.sql"), + Query::NullIndexes => include_str!("queries/null_indexes.sql"), + Query::Locks => include_str!("queries/locks.sql"), + Query::AllLocks => include_str!("queries/all_locks.sql"), + Query::LongRunningQueries => include_str!("queries/long_running_queries.sql"), + Query::Mandelbrot => include_str!("queries/mandelbrot.sql"), + Query::Outliers => include_str!("queries/outliers.sql"), + Query::RecordsRank => include_str!("queries/records_rank.sql"), + Query::SeqScans => include_str!("queries/seq_scans.sql"), + Query::TableIndexScans => include_str!("queries/table_index_scans.sql"), + Query::TableIndexesSize => include_str!("queries/table_indexes_size.sql"), + Query::TableSize => include_str!("queries/table_size.sql"), + Query::TotalIndexSize => include_str!("queries/total_index_size.sql"), + Query::TotalTableSize => include_str!("queries/total_table_size.sql"), + Query::UnusedIndexes => include_str!("queries/unused_indexes.sql"), + Query::DuplicateIndexes => include_str!("queries/duplicate_indexes.sql"), + Query::VacuumStats => include_str!("queries/vacuum_stats.sql"), + } } }